diff --git a/.gitignore b/.gitignore index d95aecc168..273696ba94 100644 --- a/.gitignore +++ b/.gitignore @@ -39,5 +39,7 @@ predicators/datasets/vlm_input_data_prompts/vision_api/response.txt side-state-view.png top-down-state-view.png -# Jetbrains IDEs -.idea/ \ No newline at end of file +# IDEs +.idea/ +.vscode/ +.run \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000000..a0cc7f0c62 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,91 @@ +# Temp Changelog + +## Mock Environment Testing Framework Development + +### Initial Development +- Created initial mock environment for testing transition graphs +- Set up basic pick-and-place task with visualization +- Established test file at `tests/spot_utils/test_mock_env_transitions.py` + +### Test Cases Development +1. Created three main test functions: + - `test_single_block_pick_place()`: Basic pick-and-place with one block + - `test_two_object_pick_place()`: Pick-and-place with two blocks + - `test_view_reach_pick_place_two_objects()`: Full sequence including view, reach, pick, and place for two objects + +### Infrastructure Improvements +- Added comprehensive docstrings for all tests +- Implemented rich logging configuration +- Created reset configuration fixture with planning parameters +- Set up proper predicate definitions and imports +- Organized visualization output in structured directories + +### Major Fixes and Changes +- Fixed type issues: + - Changed block type from `_container_type` to `_movable_object_type` + - Corrected predicate type definitions +- Added missing imports: + - Added pytest import + - Added necessary predicates +- File organization: + - Corrected output file paths + - Structured output in `mock_env_data` directory +- Enhanced test functionality: + - Added necessary predicates for proper planning + - Structured test cases to show progression of complexity + +### Current Structure +``` +mock_env_data/ +├── test_single_block_pick_place/ +├── test_two_object_pick_place/ +└── test_view_reach_pick_place_two/ +``` + +### Test Features +1. Single Block Pick-and-Place: + - Basic manipulation test + - Tests core pick-and-place functionality + - Verifies simple goal achievement + +2. Two-Object Pick-and-Place: + - Tests handling of multiple objects + - Verifies more complex goal achievement + - Tests interaction between objects + +3. View-Reach-Pick-Place Sequence: + - Tests full manipulation sequence + - Includes viewing and reaching operations + - Demonstrates complex action sequencing + - Handles multiple objects with dependencies + +### Technical Improvements +- Enhanced type handling for objects +- More comprehensive initial states +- Clearer action sequences +- Better organized output structure +- More detailed documentation +- Proper error handling and assertions + +### Documentation +- Added detailed docstrings for each test +- Included test case descriptions +- Documented output file locations +- Added configuration explanations +- Included predicate and atom descriptions + +### Configuration +- Added rich logging setup +- Implemented reset configuration fixture +- Set up planning parameters: + - Task planning heuristic + - Maximum skeletons optimization + - Necessary atoms usage + - Expected atoms checking + +### Future Work +- Consider adding more complex scenarios +- Potential for additional operator testing +- Possible expansion of visualization capabilities +- Consider adding more assertion checks +- Potential for parameterized testing \ No newline at end of file diff --git a/README.md b/README.md index 1ceb61c512..522fd38f98 100644 --- a/README.md +++ b/README.md @@ -56,3 +56,20 @@ See [these instructions](supercloud.md). * The second one is the static typing check, which uses Mypy to verify type annotations. If it doesn't work due to import errors, try `mypy -p predicators --config-file predicators/mypy.ini` from one directory up. * The third one is the linter check, which runs Pylint with the custom config file `.predicators_pylintrc` in the root of this repository. Feel free to edit this file as necessary. * The fourth one is the autoformatting check, which uses the custom config files `.style.yapf` and `.isort.cfg` in the root of this repository. + + + +# Create mock environments + +## Pick place +``` +cd predicators/predicators/spot_utils/mock_env +python mock_env_creator_manual.py --image_dir=/home/aidan/predicators/mock_task_images/pick_place --output_dir=/home/aidan/predicators/mock_env_data --env_name=MockSpotPickPlaceTwoCupEnv --mode=state +``` + + +## Drawer cleaning +``` +cd predicators/predicators/spot_utils/mock_env +python mock_env_creator_manual.py --image_dir=/home/aidan/predicators/mock_task_images/drawer_clean --output_dir=/home/aidan/predicators/mock_env_data --env_name=MockSpotDrawerCleaningEnv --mode=state +``` diff --git a/docs/codebase_structure.md b/docs/codebase_structure.md new file mode 100644 index 0000000000..0cd6ed5417 --- /dev/null +++ b/docs/codebase_structure.md @@ -0,0 +1,236 @@ +# Codebase Structure and Usage Guide + +## Overview +This codebase implements a framework for bilevel planning with learned neuro-symbolic relational abstractions. The system is designed to work with both simulated environments and real robotic systems, with a focus on learning symbolic operators for task and motion planning. + +## Directory Structure + +``` +predicators/ +├── approaches/ # Planning and learning approaches +│ ├── base_approach.py +│ ├── oracle.py +│ └── ... +├── envs/ # Environment implementations +│ ├── base_env.py +│ ├── sokoban.py +│ └── ... +├── perception/ # Perception systems +│ ├── base_perceiver.py +│ ├── spot_perceiver.py +│ └── ... +├── nsrt_learning/ # NSRT learning implementation +│ └── nsrt_learning_main.py +├── spot_utils/ # Spot robot utilities +│ ├── perception/ +│ └── mock_env/ +└── structs.py # Core data structures +``` + +## Core Components + +### 1. Environment System (`predicators/envs/`) +Environments define the world state and how it changes with actions. + +#### BaseEnv Interface +```python +class BaseEnv: + @property + def predicates(self) -> Set[Predicate]: + """Return the predicates for this environment.""" + + @property + def types(self) -> Set[Type]: + """Return the types for this environment.""" + + def reset(self, train_or_test: str, task_idx: int) -> Observation: + """Reset to initial state of given task.""" + + def step(self, action: Action) -> Observation: + """Execute action and return observation.""" +``` + +#### Environment Categories +1. **Simulated Environments** + - Fully observable (e.g., Sokoban, Cover) + - Direct state transitions + - No perception needed + +2. **Robot Environments** + - Partially observable (e.g., Spot) + - Real-world interaction + - Requires perception pipeline + - Often needs mock version for testing + +### 2. Perception System (`predicators/perception/`) + +#### BasePerceiver Interface +```python +class BasePerceiver: + def reset(self, env_task: EnvironmentTask) -> Task: + """Convert initial observation to symbolic task.""" + + def step(self, observation: Observation) -> State: + """Convert observation to symbolic state.""" +``` + +#### Perception Pipeline +1. **Raw Observation Processing** + - Image processing + - Object detection + - Point cloud processing + +2. **State Estimation** + - Object tracking + - Feature extraction + - Predicate evaluation + +### 3. Planning and Learning (`predicators/approaches/`) + +#### Approach Types +1. **Oracle Approaches** + - Use ground truth models + - Useful for testing + +2. **Learning Approaches** + - NSRT learning + - Predicate invention + - Skill learning + +#### NSRT Learning Pipeline (`nsrt_learning/`) +1. Data segmentation +2. Symbolic operator learning +3. Option learning +4. Sampler learning +5. NSRT finalization + +### 4. Mock Spot Robot Environment System +For testing robot environments without hardware: + +#### Components +1. **Mock Spot Robot Environment** + ```python + class MockEnv(BaseEnv): + def __init__(self): + self._transition_graph = self._load_transitions() + self._image_database = self._load_images() + + def reset(self): + return self._get_mock_observation() + + def step(self, action): + return self._simulate_transition(action) + ``` + +2. **Mock Perceiver** + ```python + class MockPerceiver(BasePerceiver): + def reset(self, env_task): + return self._create_symbolic_task(env_task) + + def step(self, observation): + return self._process_mock_observation(observation) + ``` + +3. **Data Collection Tools** + ```python + class DataCollector: + def collect_state_data(self): + """Collect images and state information.""" + + def build_transition_graph(self): + """Create state transition graph.""" + ``` + +## Running the System + +### 1. Basic Usage +```bash +# Run with oracle approach +python predicators/main.py --env sokoban --approach oracle --seed 0 + +# Run with learning +python predicators/main.py --env cover --approach nsrt_learning --seed 0 +``` + +### 2. Environment Setup +```bash +# Required environment variables +export PYTHONHASHSEED=0 # Required for deterministic hashing +export PYTHONPATH=/path/to/predicators # Add to Python path +``` + +### 3. Development Setup +```bash +# Install development dependencies +pip install -e .[develop] + +# Run tests +pytest tests/ + +# Run type checking +mypy . + +# Run linter +pytest . --pylint +``` + +## Workflow Examples + +### 1. Creating a New Environment + +```python +# 1. Define environment +class NewEnv(BaseEnv): + def __init__(self): + self._setup_types() + self._setup_predicates() + + def _setup_predicates(self): + self._IsGraspable = Predicate("IsGraspable", + [self.object_type], + self._IsGraspable_holds) + # ... more predicates + +# 2. Create perceiver if needed +class NewPerceiver(BasePerceiver): + def reset(self, env_task): + state = self._observation_to_state(env_task.init_obs) + return Task(state, self._create_goal(env_task)) + +# 3. Define mock version for testing +class MockNewEnv(BaseEnv): + def __init__(self): + self._load_mock_data() +``` + +### 2. Running with Mock Environment + +1. **Collect Data** + +2. **Create Mock Environment** + +3. **Test Pipeline** + +### 3. Development Workflow + +1. **Implementation** + - Implement environment classes + - Create perceiver if needed + - Define predicates and types + - Create mock version + +2. **Testing** + ```bash + # Run unit tests + pytest tests/envs/test_new_env.py + + # Run integration tests + pytest tests/test_integration.py + ``` + +3. **Debugging** + - Use mock environment for testing + - Add logging and visualization + - Test predicate evaluation + diff --git a/docs/create_new_mock_robot_task_with_canonical_states.md b/docs/create_new_mock_robot_task_with_canonical_states.md new file mode 100644 index 0000000000..efc15160de --- /dev/null +++ b/docs/create_new_mock_robot_task_with_canonical_states.md @@ -0,0 +1,159 @@ +# Creating Mock Robot Tasks with Images and Canonical State Mappings + +This guide explains how to create mock robot tasks with unique image states and canonical state mappings. +Canonical states are states that are equivalent under key predicates. + +## Overview + +The mock environment system now supports: +1. Tracking unique (canonical) states based on view and world state +2. Mapping ground atoms to states and canonical states +3. Managing key atoms for important state properties +4. Using manually collected images (e.g. from phone) for state observations + +## State Management + +### Unique States + +States are considered unique based on two criteria: +1. View state: Objects in view and in hand +2. World state: Ground atoms that are true + +Multiple images can map to the same logical state. For example: +- Different camera angles of the same scene +- Different lighting conditions +- Slight variations in object positions + +### Ground Atom Mappings + +The system tracks: +1. Which states have each ground atom +2. Which canonical states have each ground atom +3. Key atoms that are important for the task + +Example: +```python +# Create environment and creator +env = MockSpotDrawerCleaningEnv() +creator = MockEnvCreatorBase("mock_env_data/my_task", env=env) + +# Get states where drawer is closed +drawer_closed_atom = GroundAtom(_DrawerClosed, [env.drawer]) +drawer_states = creator.get_states_with_atom(drawer_closed_atom) +print(f"States with closed drawer: {drawer_states}") + +# Get canonical states where cup is in container +inside_cup_atom = GroundAtom(_Inside, [env.cup, env.container]) +canonical_states = creator.get_canonical_states_with_atom(inside_cup_atom) +print(f"Canonical states with cup in container: {canonical_states}") + +# Add new key atom to track +creator.add_key_atom(inside_cup_atom) +``` + +## Using Phone Images + +### Method 1: CLI Tool + +1. Take photos of each state with your phone +2. Transfer HEIC images to your computer +3. Run the CLI tool: + +```bash +python -m predicators.spot_utils.mock_env.mock_env_creator_base \ + --output_dir mock_env_data/my_task \ + --image_dir path/to/phone/images \ + --env_name my_new_task_env +``` + +The tool will: +- Show available states and their properties +- Let you map each image to a state +- Track unique states and their mappings +- Save mappings for future use + +### Method 2: Python API + +1. Organize your images: +``` +phone_images/ +├── drawer_closed.HEIC +├── drawer_open.HEIC +└── ... +``` + +2. Create mapping script: +```python +from pathlib import Path +from predicators.spot_utils.mock_env.mock_env_creator_base import MockEnvCreatorBase + +# Create environment and creator +env = MyNewTaskEnv() +creator = MockEnvCreatorBase("mock_env_data/my_task", env=env) + +# Define image mappings +image_dir = Path("phone_images") +state_images = { + "0": {"cam1.seed0.rgb": (str(image_dir / "drawer_closed.HEIC"), "rgb")}, + "1": {"cam1.seed0.rgb": (str(image_dir / "drawer_open.HEIC"), "rgb")}, + ... +} + +# Add images for each state +for state_id, images in state_images.items(): + creator.add_state_from_raw_images( + raw_images=images, + state_id=state_id, + objects_in_view=..., # Define based on state + objects_in_hand=..., # Define based on state + gripper_open=... # Define based on state + ) + +# Save state mapping +creator.save_state_mapping() +``` + +## State Mapping File + +The system saves state mappings in `state_mapping.yaml`: + +```yaml +state_to_canonical: + "0": "0" # This state is canonical + "1": "0" # This state maps to state 0 +canonical_state_to_id: + "0": ["0", "1"] # State 0 has two equivalent states +unique_view_states: + "view:cup,table|hand:": ["0", "1"] # States with same view +unique_world_states: + "world:HandEmpty,On_cup_table": ["0", "1"] # States with same atoms +atom_to_states: + "DrawerClosed(drawer)": ["0", "6"] # States where drawer is closed +atom_to_canonical_states: + "Inside(cup,container)": ["3", "5"] # Canonical states with cup in container +key_atoms: + - "DrawerClosed(drawer)" + - "Inside(cup,container)" +``` + +## Best Practices + +1. State Management: + - Use meaningful state IDs + - Document state meanings + - Track important atoms as key atoms + +2. Image Collection: + - Take consistent photos + - Use good lighting + - Capture key state features + +3. Testing: + - Verify state uniqueness + - Check atom mappings + - Test with equivalent states + +4. Documentation: + - Document state meanings + - List key atoms + - Explain state equivalences \ No newline at end of file diff --git a/docs/creating_new_mock_robot_tasks.md b/docs/creating_new_mock_robot_tasks.md new file mode 100644 index 0000000000..8aa921b4d0 --- /dev/null +++ b/docs/creating_new_mock_robot_tasks.md @@ -0,0 +1,205 @@ +# Creating New Mock Robot Tasks (Inspired by Spot Environment) + +This guide explains how to create new mock tasks that simulate Spot robot behaviors. Mock tasks are used to test and develop task planning without requiring the physical robot. We'll use the two-cup pick-and-place task as an example. + +## Overview + +A mock task consists of: +1. A task-specific environment that defines objects, states, and valid actions +2. A sequence of RGB-D images that represent the robot's observations +3. A transition graph showing how actions change the environment state +4. Metadata about object visibility and gripper state for each observation + +## 1. Create a Task-Specific Environment + +Create a new environment class that inherits from `MockSpotEnv`. This class defines what objects exist in the environment and their relationships: + +```python +class MockSpotPickPlaceTwoCupEnv(MockSpotEnv): + """Mock environment for Spot robot to pick and place two cups.""" + + def __init__(self, name: str = "pick_place") -> None: + super().__init__() + self.name = name + + # Define task objects using Spot's type system + self.robot = Object("robot", _robot_type) + self.cup1 = Object("cup1", _container_type) + self.cup2 = Object("cup2", _container_type) + self.table = Object("table", _immovable_object_type) + self.target = Object("target", _container_type) + + # Store all objects that exist in this task + self.objects = {self.robot, self.cup1, self.cup2, self.table, self.target} + + # Define initial state (what is true at the start) + self.initial_atoms = { + # Robot starts with empty hand + GroundAtom(_HandEmpty, [self.robot]), + GroundAtom(_NotHolding, [self.robot, self.cup1]), + GroundAtom(_NotHolding, [self.robot, self.cup2]), + + # Cups start on the table + GroundAtom(_On, [self.cup1, self.table]), + GroundAtom(_On, [self.cup2, self.table]), + GroundAtom(_On, [self.target, self.table]), + + # Objects are reachable and visible + GroundAtom(_Reachable, [self.robot, self.cup1]), + GroundAtom(_Reachable, [self.robot, self.cup2]), + GroundAtom(_InHandView, [self.robot, self.cup1]), + GroundAtom(_InHandView, [self.robot, self.cup2]), + + # ... other necessary predicates ... + } + + # Define goal state (what should be true at the end) + self.goal_atoms = { + GroundAtom(_Inside, [self.cup1, self.target]), + GroundAtom(_Inside, [self.cup2, self.target]) + } +``` + +## 2. Select Required Operators + +Choose which actions from the Spot robot's capabilities are needed for this task: + +```python +def _create_operators(self) -> Iterator[STRIPSOperator]: + """Define what actions are available in this task.""" + all_operators = list(super()._create_operators()) + + # Select only the operators needed for pick-and-place + op_names_to_keep = { + "MoveToReachObject", # Move robot to reach an object + "MoveToHandViewObject", # Move hand camera to see object + "PickObjectFromTop", # Pick up object from above + "PlaceObjectOnTop", # Place object on surface + "DropObjectInside" # Place object in container + } + + # Filter operators + for op in all_operators: + if op.name in op_names_to_keep: + yield op +``` + +## 3. Create a Test File + +Create a test that demonstrates the task execution and validates the mock environment: + +```python +def test_two_cup_pick_place_with_manual_images(): + """Test a mock task where Spot moves two cups into a target container.""" + # Set up configuration + test_name = "test_two_cup_pick_place" + test_dir = os.path.join("mock_env_data", test_name) + utils.reset_config({ + "env": "mock_spot", + "approach": "oracle", + "seed": 123, + "num_train_tasks": 0, + "num_test_tasks": 1, + "mock_env_data_dir": test_dir + }) + + # Create mock environment for this specific task + env = MockSpotPickPlaceTwoCupEnv(name=test_name) + + # Create environment creator to manage states and images + creator = ManualMockEnvCreator(test_dir, env=env) + + # Generate and visualize the task's transition graph + name = f'Transition Graph, {env.name.replace("_", " ").title()}' + creator.plan_and_visualize(env.initial_atoms, env.goal_atoms, env.objects, task_name=name) +``` + +## 4. Add Mock Observations + +For each state in the task, provide mock RGB-D images that represent what Spot's cameras would see: + +```python +# Define what Spot observes in each state +test_state_images = { + "state_0": { # Initial state - both cups on table + "view1": { # Front view + "cam1": { # Hand camera + "rgb_img": (rgb_path, "rgb"), + "depth_img": (depth_path, "depth") + }, + "cam2": { # Navigation camera + "rgb_img": (rgb_path, "rgb") + } + }, + "view2": { # Side view + "cam1": { + "rgb_img": (rgb_path, "rgb") + } + } + }, + "state_1": { # Holding first cup + "view1": { + "cam1": { + "rgb_img": (rgb_path, "rgb"), + "depth_img": (depth_path, "depth") + } + } + }, + # ... states for entire task sequence ... +} + +# Add each state's observations to the environment +for state_id, views in test_state_images.items(): + creator.add_state_from_multiple_images( + views, + state_id=state_id, + objects_in_view=list({env.cup1.name, env.cup2.name, env.table.name, env.target.name}), + objects_in_hand=[env.cup1.name] if state_id == "state_1" else + [env.cup2.name] if state_id == "state_3" else [], + gripper_open=(state_id not in ["state_1", "state_3"]) + ) +``` + +## 5. Directory Structure + +The mock task creates this structure to simulate Spot's data: +``` +mock_env_data/test_two_cup_pick_place/ +├── images/ # Mock camera observations +│ ├── state_0/ # Initial state +│ │ ├── view1/ # Front view +│ │ │ ├── cam1_rgb.npy # Hand camera RGB +│ │ │ ├── cam1_depth.npy # Hand camera depth +│ │ │ ├── cam2_rgb.npy # Navigation camera RGB +│ │ │ └── metadata.yaml # What objects are visible/held +│ │ └── view2/ # Side view +│ │ └── cam1_rgb.npy # Another camera angle +│ └── state_1/ # Next state +│ └── ... +├── transitions/ # Task execution visualization +│ └── Transition Graph.html # Shows action sequence +└── plan.yaml # Task execution plan +``` + +## Tips for Mock Tasks + +1. **Task Definition**: + - Keep tasks focused and specific + - Define clear initial and goal states + - Only include necessary objects and predicates + +2. **Operators**: + - Use only operators that match Spot's capabilities + - Include all prerequisites (e.g., need to see object before picking) + - Consider physical constraints (e.g., reachability) + +3. **Mock Images**: + - Use realistic camera positions (hand camera, navigation camera) + - Include depth information for manipulation + - Match image content to state description + +4. **Testing**: + - Verify all state transitions are possible + - Check that images match state descriptions + - Validate gripper state and object tracking + - Test with different initial conditions \ No newline at end of file diff --git a/docs/fm_planning_approaches.md b/docs/fm_planning_approaches.md new file mode 100644 index 0000000000..5f40337b86 --- /dev/null +++ b/docs/fm_planning_approaches.md @@ -0,0 +1,148 @@ +# Foundation Model Planning Approaches + +This document describes the language model-based planning approaches and execution monitoring strategies available in the codebase. + +## Planning Approaches + +### LLM Bilevel Planning Approach + +The `LLMBilevelPlanningApproach` uses a large language model (LLM) to guide bilevel planning. Key features: + +- Uses LLM to generate high-level option plans +- Converts option plans into partial policies to guide A* search +- Falls back to regular planning if LLM suggestions fail +- Assumes one-to-one mapping between options and NSRTs + +Example usage: +```bash +python predicators/main.py --approach llm_bilevel_planning \ + --seed 0 \ + --strips_learner oracle \ + --env pddl_blocks_procedural_tasks \ + --num_train_tasks 3 \ + --num_test_tasks 1 +``` + +### VLM Open Loop Approach + +The `VLMOpenLoopApproach` uses a vision-language model (VLM) to directly generate plans from visual observations. Key features: + +- Takes RGB images as input along with text descriptions +- Can use few-shot examples from training demonstrations +- Generates option plans directly from visual input +- Executes plans in open-loop fashion + +Example usage: +```bash +python predicators/main.py --approach vlm_open_loop \ + --env burger \ + --seed 0 \ + --num_train_tasks 0 \ + --num_test_tasks 1 \ + --bilevel_plan_without_sim True \ + --vlm_model_name gpt-4o +``` + +### VLM Bilevel Planning Approach + +The `VLMBilevelPlanningApproach` combines vision-language capabilities with bilevel planning. Key features: + +- Uses VLM to generate option plans from visual input +- Converts VLM suggestions into search guidance +- Integrates with execution monitoring +- Combines benefits of both VLM and bilevel planning + +Example usage: +```bash +python predicators/main.py --approach vlm_bilevel_planning \ + --env mock_spot_pick_place_two_cup \ + --seed 0 \ + --num_train_tasks 0 \ + --num_test_tasks 1 \ + --bilevel_plan_without_sim True \ + --execution_monitor expected_atoms \ + --vlm_model_name gpt-4o +``` + +## Execution Monitoring + +The codebase provides several execution monitoring strategies to handle uncertainty and trigger replanning when needed. + +### Expected Atoms Monitor + +The `ExpectedAtomsExecutionMonitor` checks if the expected atoms from the plan match reality: + +- Compares expected atoms from plan against current state +- Works with both regular and VLM predicates +- Triggers replanning if expectations are violated +- Best suited for bilevel planning approaches + +Example usage: +```bash +--execution_monitor expected_atoms +``` + +### MPC Execution Monitor + +The `MpcExecutionMonitor` implements a model-predictive control strategy: + +- Always triggers replanning after the first timestep +- Enables continuous plan adaptation +- Useful for handling dynamic environments +- Works with any planning approach + +Example usage: +```bash +--execution_monitor mpc +``` + +### Trivial Execution Monitor + +The `TrivialExecutionMonitor` provides a baseline that never triggers replanning: + +- Never suggests replanning +- Useful for testing and debugging +- Baseline for comparing monitoring strategies + +Example usage: +```bash +--execution_monitor trivial +``` + +## Choosing an Approach + +Here are some guidelines for choosing between approaches: + +1. **LLM Bilevel Planning**: + - Best for tasks with clear symbolic descriptions + - When you have good language prompts + - Tasks that benefit from guided search + +2. **VLM Open Loop**: + - Best for visually-guided tasks + - When you have good visual demonstrations + - Simple tasks with reliable execution + +3. **VLM Bilevel Planning**: + - Best for complex visual tasks + - When you need robust execution + - Tasks that benefit from both visual and symbolic reasoning + +## Choosing a Monitor + +Guidelines for choosing execution monitors: + +1. **Expected Atoms Monitor**: + - Use with bilevel planning approaches + - When you have clear expected states + - Tasks with discrete state transitions + +2. **MPC Monitor**: + - Use in dynamic environments + - When continuous replanning is beneficial + - Tasks with uncertainty + +3. **Trivial Monitor**: + - Use for debugging + - Simple environments + - When testing base planner behavior \ No newline at end of file diff --git a/docs/mock_spot_perceiver.md b/docs/mock_spot_perceiver.md new file mode 100644 index 0000000000..c7bc166219 --- /dev/null +++ b/docs/mock_spot_perceiver.md @@ -0,0 +1,459 @@ +# Mock Spot Perceiver Documentation + +## Overview + +The mock Spot perceiver system provides a simulated perception pipeline for testing and development without requiring physical Spot robot hardware. It handles: +- RGBD image observations +- Object detection and tracking +- VLM (Vision Language Model) predicate evaluation +- State estimation and belief updates +- Drawer observation and content belief updates + +## Object Handling + +### Object System + +Objects in the mock environment are managed by the environment creator and passed through as `Container[Object]`. Key points: + +1. **Object Types**: + ```python + @dataclass + class Object: + name: str # Unique identifier for the object + type: str # Object type (e.g. "cup", "table", "drawer") + parent_type: Optional[str] = None # Parent type for inheritance + ``` + +2. **Object Storage**: + - All objects are stored and passed as `Container[Object]` + - No string-based object references + - Direct object instance usage throughout the system + - Objects are created and managed by the environment creator + +3. **Object Flow**: +``` +Environment Creator + │ + ├── Creates and manages Object instances + │ ├── Stores objects in Dict[str, Object] + │ └── Maintains objects with proper types + │ + ├── Passes Container[Object] to environment + │ └── Covariant container for type compatibility + │ + └── Environment and perceiver use objects directly +``` + +4. **Key Implementation Details**: + - Use `Container[Object]` instead of `Set[Object]` for covariant type compatibility + - Environment creator maintains object dictionary for lookup + - Objects are passed by reference to maintain identity + - Type hierarchy supports inheritance through parent_type + +5. **Best Practices**: + - Always use Container[Object] for collections to avoid type variance issues + - Create objects through environment creator to ensure consistency + - Maintain object identity across the system + - Use type hierarchy for predicate compatibility + +### Observation Structure + +Two main observation classes are used: + +1. `_SavedMockSpotObservation`: +```python +@dataclass(frozen=True) +class _SavedMockSpotObservation: + images: Optional[Dict[str, RGBDImageWithContext]] # Camera images + gripper_open: bool # Gripper state + objects_in_view: Container[Object] # Visible objects + objects_in_hand: Container[Object] # Held objects + state_id: str # Unique state ID + atom_dict: Dict[str, bool] # Predicate atoms + non_vlm_atom_dict: Optional[Set[GroundAtom]] # Non-VLM atoms +``` + +2. `_MockSpotObservation` (extends `_SavedMockSpotObservation`): +```python +@dataclass(frozen=True) +class _MockSpotObservation: + # Inherits all fields from _SavedMockSpotObservation + vlm_atom_dict: Optional[Dict[VLMGroundAtom, bool]] # VLM predicate results + vlm_predicates: Optional[Set[VLMPredicate]] # Active VLM predicates +``` + +### Object Creation and Management + +1. **Environment Creator**: + ```python + class ManualMockEnvCreator(MockEnvCreatorBase): + def __init__(self, image_dir: str, objects: Dict[str, Object]) -> None: + super().__init__(image_dir) + self._objects = objects # Store object dictionary + ``` + +2. **State Management**: + ```python + def add_state(self, + state_id: str, + views: Dict[str, Dict[str, Dict[str, np.ndarray]]], + objects_in_view: Container[Object], + objects_in_hand: Container[Object], + gripper_open: bool = True) -> None: + # Save state with object references + state_data = { + "objects_in_view": [obj.name for obj in objects_in_view], + "objects_in_hand": [obj.name for obj in objects_in_hand], + ... + } + ``` + +3. **Loading Objects**: + ```python + def add_state_from_images(self, + state_id: Optional[str] = None, + objects_in_view: Optional[Container[Object]] = None, + objects_in_hand: Optional[Container[Object]] = None, + ...): + # Initialize empty containers if None + if objects_in_view is None: + objects_in_view = set() + if objects_in_hand is None: + objects_in_hand = set() + ``` + +## Perceiver System + +### Core Components + +1. **State Management**: + ```python + class MockSpotPerceiver: + _camera_images: Dict[str, RGBDImageWithContext] # Current images + _gripper_open: bool # Gripper state + _objects_in_view: Set[Object] # Visible objects + _objects_in_hand: Set[Object] # Held objects + _vlm_predicates: Set[VLMPredicate] # VLM predicates + _vlm_atom_dict: Dict[VLMGroundAtom, bool] # VLM atom values + _non_vlm_atoms: Set[GroundAtom] # Non-VLM atoms + ``` + +2. **Key Methods**: + - `get_observation()`: Returns current observation + - `_update_state_from_observation()`: Updates internal state + - `_obs_to_state()`: Converts observation to State object + +### State vs Observation + +1. **State**: + - Represents complete world state + - Includes all ground atoms (VLM and non-VLM) + - Used for planning and action selection + - Created by combining: + - VLM predicate evaluations + - Non-VLM predicates from environment + - Object positions and properties + +2. **Observation**: + - Raw sensor data and immediate percepts + - Includes: + - RGBD images + - Detected objects + - Gripper state + - VLM predicate results + - More limited than state (partial observability) + +## Belief State Updates + +### VLM Predicate Handling + +1. **Predicate Types**: + ```python + # Non-VLM predicates (environment-defined) + _On = Predicate("On", [_movable_object_type, _base_object_type]) + + # VLM predicates (vision-based) + _On = VLMPredicate( + "On", [_movable_object_type, _base_object_type], + prompt="This predicate typically describes..." + ) + ``` + +2. **Belief Update Process**: + The belief update happens in three steps: + + a) **Check Consistency of New Labels**: + ```python + # Collect Known/Unknown pairs from current VLM evaluation + # Being pessimistic: if unknown is true OR known is false, treat as unknown + if known_val and unknown_val: # Both True is inconsistent + logging.warning("Inconsistent Known/Unknown values...") + if unknown_val or not known_val: + curr_vlm_atom_values[known_atom] = False + curr_vlm_atom_values[unknown_atom] = True + ``` + + b) **Basic Update**: + - Update any atom that has a non-None value from current observation + - Preserves previous values for atoms not in current observation + + c) **Override with Previous Knowledge**: + - If a predicate was Known=True in previous step, it stays Known=True + - Corresponding Unknown predicate is set to False + - Otherwise, keep values from current observation + +3. **Key Principles**: + - Known predicates cannot become unknown (monotonic knowledge) + - Being pessimistic: treat as unknown if: + - Unknown is true OR Known is false + - Both Known and Unknown are true/false (inconsistent) + - Non-VLM predicates come directly from environment + - VLM predicates are evaluated online using images + +### State Construction + +1. **State Components**: + - Complete world state representation + - Combines VLM and non-VLM atoms + - Includes camera images and visible objects + - Tracks belief state for partially observable predicates + +2. **State Construction Code**: + ```python + def _obs_to_state(self, obs: _MockSpotObservation) -> State: + # Create state with all atoms + state_dict = {} + + # Add VLM atoms if enabled + if CFG.mock_env_vlm_eval_predicate and self._vlm_atom_dict: + for atom, value in self._vlm_atom_dict.items(): + if value: + state_dict[atom] = True + + # Add non-VLM atoms + if self._non_vlm_atoms: + for atom in self._non_vlm_atoms: + state_dict[atom] = True + + # Create partial perception state with additional info + state = _PartialPerceptionState( + state_dict, # Base state data + camera_images=self._camera_images if CFG.mock_env_vlm_eval_predicate else None, + visible_objects=self._objects_in_view, + vlm_atom_dict=self._vlm_atom_dict, + vlm_predicates=self._vlm_predicates, + ) + + return state + ``` + +3. **Key Components**: + - `state_dict`: Core state data with all true atoms + - `camera_images`: Current RGBD images (if VLM enabled) + - `visible_objects`: Objects currently in view + - `vlm_atom_dict`: Current VLM predicate evaluations + - `vlm_predicates`: Active VLM predicates + +4. **Partial Observability**: + - State tracks both fully and partially observable predicates + - Camera images maintained for VLM evaluation + - Visible objects list for perception tracking + - VLM atom dictionary preserves belief state + +### Drawer Observation System + +1. **Drawer State Predicates**: + ```python + # Physical state predicates + _DrawerOpen = Predicate("DrawerOpen", [_container_type]) + _DrawerClosed = Predicate("DrawerClosed", [_container_type]) + + # Belief state predicates + _Unknown_ContainerEmpty = Predicate("Unknown_ContainerEmpty", [_container_type]) + _Known_ContainerEmpty = Predicate("Known_ContainerEmpty", [_container_type]) + _BelieveTrue_ContainerEmpty = Predicate("BelieveTrue_ContainerEmpty", [_container_type]) + _BelieveFalse_ContainerEmpty = Predicate("BelieveFalse_ContainerEmpty", [_container_type]) + ``` + +2. **Belief Update Process**: + The drawer observation system follows these principles: + + a) **Initial State**: + - Drawer content starts as unknown (`Unknown_ContainerEmpty`) + - Physical state (open/closed) is known + - No beliefs about contents + + b) **Observation Process**: + ```python + # Drawer must be open for observation + if not _DrawerOpen(drawer): + return # Cannot observe closed drawer + + # Update knowledge state + del_effs.add(_Unknown_ContainerEmpty(drawer)) + add_effs.add(_Known_ContainerEmpty(drawer)) + + # Update belief based on observation + if found_empty: + add_effs.add(_BelieveTrue_ContainerEmpty(drawer)) + else: + add_effs.add(_BelieveFalse_ContainerEmpty(drawer)) + ``` + + c) **Knowledge Persistence**: + - Once drawer content is known, it stays known + - Beliefs about contents can be updated + - Physical state can change independently + +3. **Key Principles**: + - Drawer must be open for observation + - Knowledge is monotonic (cannot become unknown) + - Beliefs can change with new observations + - Physical and belief states are tracked separately + +### State Construction + +1. **State Components**: + - Complete world state representation + - Combines physical and belief predicates + - Tracks drawer state and contents + - Maintains observation history + +2. **State Construction Code**: + ```python + def _obs_to_state(self, obs: _MockSpotObservation) -> State: + # Create state with all atoms + state_dict = {} + + # Add physical state atoms + if self._non_vlm_atoms: + for atom in self._non_vlm_atoms: + state_dict[atom] = True + + # Add belief state atoms + if self._belief_atoms: + for atom in self._belief_atoms: + state_dict[atom] = True + + # Create state with additional info + state = _PartialPerceptionState( + state_dict, + camera_images=self._camera_images, + visible_objects=self._objects_in_view, + belief_atoms=self._belief_atoms + ) + + return state + ``` + +3. **Key Components**: + - `state_dict`: Core state data with all true atoms + - `_belief_atoms`: Set of current belief predicates + - `_non_vlm_atoms`: Physical state predicates + - `_camera_images`: Current visual observations + +## Testing + +### Test Cases + +1. **Basic Drawer Observation**: + ```python + def test_drawer_observation(): + # Initial state - drawer content unknown + initial_atoms = { + _HandEmpty(robot), + _DrawerOpen(drawer), + _Unknown_ContainerEmpty(drawer) + } + + # After observation finding empty + observation_atoms = { + _Known_ContainerEmpty(drawer), + _BelieveTrue_ContainerEmpty(drawer) + } + + # After observation finding objects + observation_atoms = { + _Known_ContainerEmpty(drawer), + _BelieveFalse_ContainerEmpty(drawer), + _Inside(apple, drawer) + } + ``` + +2. **State Transitions**: + ```python + # Valid transitions: + Unknown -> Known + BelieveTrue # Found empty + Unknown -> Known + BelieveFalse # Found objects + + # Invalid transitions: + Known -> Unknown # Cannot lose knowledge + ``` + +3. **Best Practices**: + - Always check drawer is open before observation + - Update both knowledge and belief state + - Maintain monotonicity of knowledge + - Track physical state separately from beliefs + +## TODOs + +### High Priority +1. **Object Management**: + - [ ] Update environment creator to properly save object type information + - [ ] Add object versioning/validation when loading from disk + - [ ] Handle object type inheritance in predicate evaluation + +2. **VLM Integration**: + - [ ] Improve VLM predicate evaluation with object type checking + - [ ] Add caching for VLM results to avoid redundant evaluation + - [ ] Handle VLM service failures gracefully + +3. **State Management**: + - [ ] Add proper state validation when loading from disk + - [ ] Implement state diffing for efficient updates + - [ ] Add state versioning for backward compatibility + +### Medium Priority +1. **Testing**: + - [ ] Add comprehensive tests for object type handling + - [ ] Add tests for VLM predicate evaluation + - [ ] Add tests for state serialization/deserialization + +2. **Documentation**: + - [ ] Add examples for common object manipulation scenarios + - [ ] Document best practices for object type design + - [ ] Add troubleshooting guide for common issues + +3. **Performance**: + - [ ] Optimize VLM batch evaluation + - [ ] Add object caching for frequently used objects + - [ ] Optimize state updates for large object sets + +### Low Priority +1. **Features**: + - [ ] Add support for dynamic object type creation + - [ ] Add object property validation + - [ ] Add object relationship tracking + +2. **Tooling**: + - [ ] Add visualization tools for object relationships + - [ ] Add debugging tools for object state + - [ ] Add profiling tools for VLM evaluation + +## Best Practices + +1. **VLM Predicate Design**: + - Use clear, specific prompts + - Consider object type hierarchies + - Handle ambiguous cases + +2. **State Management**: + - Preserve known predicate values + - Handle partial observability + - Maintain belief consistency + +3. **Error Handling**: + - Validate object types + - Check image availability + - Handle VLM classification failures diff --git a/docs/planning_with_mock_spot_env.md b/docs/planning_with_mock_spot_env.md new file mode 100644 index 0000000000..7470caf3ff --- /dev/null +++ b/docs/planning_with_mock_spot_env.md @@ -0,0 +1,572 @@ +# Planning with the Mock Spot Environment + +This guide explains how to use the mock Spot environment for testing planning functionality without requiring actual hardware. It covers environment setup, task creation, perception handling, and the planning pipeline. + +## Overview + +The mock Spot environment provides a way to test planning using saved images and VLM-based perception, similar to the real Spot environment but without requiring physical robot interaction. The key components are: + +- **MockSpotEnv**: Simulates the Spot environment for testing, handles state transitions and action execution +- **MockSpotPerceiver**: Manages image-based perception using saved RGBD images, tracks environment state +- **ManualMockEnvCreator**: Creates and manages mock states, handles RGB-D image storage + +## VLM Predicate Support + +The mock perceiver supports VLM-based predicates similar to the real Spot environment: + +1. Configuration: +```python +utils.reset_config({ + "env": "mock_spot", + "spot_vlm_eval_predicate": True, # Enable VLM predicate evaluation +}) +``` + +2. VLM Predicate Definition: +```python +# Define types for predicates +obj_type = Type("object", ["x", "y", "z"]) +container_type = Type("container", ["x", "y", "z"], parent=obj_type) + +# Create VLM predicates +inside_pred = VLMPredicate( + "Inside", [obj_type, container_type], + prompt="This predicate is true if the first object is inside the second object (container)." +) +on_pred = VLMPredicate( + "On", [obj_type, obj_type], + prompt="This predicate is true if the first object is on top of the second object." +) +``` + +3. State Management: +```python +# Initialize perceiver with VLM predicates +perceiver.update_state( + gripper_open=True, + objects_in_view=set(), + objects_in_hand=set(), + vlm_predicates={inside_pred, on_pred} +) + +# Save images for perception +perceiver.save_image(RGBDImageWithContext( + rgb=rgb_image, + depth=depth_image, + camera_name="mock_camera", + image_rot=0.0, + world_tform_camera=SE3Pose(x=0.0, y=0.0, z=0.0, rot=np.eye(3)), + depth_scale=1.0, + transforms_snapshot=FrameTreeSnapshot(), + frame_name_image_sensor="mock_camera", + camera_model=None +)) +``` + +## Pipeline Understanding + +### 1. Main Pipeline Flow (main.py) +1. **Environment Creation** + ```python + env = create_new_env(CFG.env, do_cache=True, use_gui=CFG.use_gui) + ``` + - Creates MockSpotEnv instance + - Sets up action space and predicates + - Initializes environment state + +2. **Perceiver Setup** + ```python + perceiver = create_perceiver(CFG.perceiver) # Creates MockSpotPerceiver + ``` + - Manages observations from mock environment + - Handles RGB-D images and object states + - Tracks gripper and object states + +3. **Task Creation** + ```python + env_train_tasks = env.get_train_tasks() + train_tasks = [perceiver.reset(t) for t in env_train_tasks] + ``` + - Defines initial and goal states + - Sets up object configurations + - Creates task instances + +4. **Approach Setup** + ```python + approach = create_approach(approach_name, preds, options, env.types, + env.action_space, stripped_train_tasks) + ``` + - Sets up planning approach (oracle for testing) + - Configures predicates and options + - Initializes action space + +5. **Planning and Execution** + ```python + cogman = CogMan(approach, perceiver, execution_monitor) + results = _run_testing(env, cogman) + ``` + - Plans actions to achieve goals + - Executes actions in environment + - Monitors execution progress + +### 2. Mock Environment Components + +1. **ManualMockEnvCreator** (from test_mock_env_manual_images.py) + - Creates and manages mock states + - Handles RGB-D image storage + - Tracks object and gripper states + - Manages state transitions + +2. **MockSpotPerceiver** (mock_spot_perceiver.py) + - Provides observations to planner + - Manages mock sensor data + - Tracks environment state + - Interfaces with MockSpotEnv + +## Inference Time Setup + +### 1. MockSpotPerceiver Configuration +```python +# Enable VLM predicate evaluation in config +utils.reset_config({ + "env": "mock_spot", + "spot_vlm_eval_predicate": True, # Enable VLM predicate evaluation +}) + +# Initialize perceiver with data directory +perceiver = MockSpotPerceiver(data_dir="path/to/mock_env_data") +``` + +### 2. State Management +The mock perceiver maintains several key pieces of state: +- RGBD images with camera context +- Objects visible to the robot +- Objects held in the gripper +- Gripper state (open/closed) +- VLM predicates and atoms for perception-based planning + +### 3. Observation Flow +1. **Image Updates**: +```python +# Save new RGBD image for perception +perceiver.save_image(RGBDImageWithContext( + rgb=rgb_image, + depth=depth_image, + camera_name="mock_camera", + image_rot=0.0, + world_tform_camera=SE3Pose(x=0.0, y=0.0, z=0.0, rot=np.eye(3)), + depth_scale=1.0, + transforms_snapshot=FrameTreeSnapshot(), + frame_name_image_sensor="mock_camera", + camera_model=None +)) +``` + +2. **State Updates**: +```python +# Update environment state +perceiver.update_state( + gripper_open=True, + objects_in_view={"cup", "table"}, + objects_in_hand=set(), + vlm_predicates=vlm_predicates, # Set of VLM predicates + vlm_atom_dict=vlm_atom_dict, # Dictionary of VLM atoms + camera_images=camera_images # Current camera images +) +``` + +3. **Getting Observations**: +```python +# Get current observation +obs = perceiver.get_observation() +assert obs.rgbd is not None # RGBD image data +assert obs.gripper_open # Gripper state +assert obs.objects_in_view # Set of visible objects +assert obs.objects_in_hand # Set of held objects +assert obs.vlm_predicates is not None # VLM predicates if enabled +assert obs.vlm_atom_dict is not None # VLM atoms if enabled +``` + +### 4. Directory Structure +Mock environment data should be organized as: +``` +mock_env_data/ +├── images/ +│ ├── state_0/ +│ │ ├── rgb.npy +│ │ └── depth.npy +│ ├── state_1/ +│ │ ├── rgb.npy +│ │ └── depth.npy +│ └── ... +└── graph.json # Contains state and transition information +``` + +### 5. Best Practices +1. **Image Management**: + - Store RGBD images in numpy format + - Include camera context for proper transformation + - Maintain consistent image dimensions + +2. **State Tracking**: + - Update state after each action + - Track objects entering/leaving view + - Maintain gripper state accuracy + - Keep VLM predicates synchronized + +3. **Error Handling**: + - Validate image data before saving + - Check state consistency after updates + - Handle missing or corrupt data gracefully + +4. **Testing**: + - Verify image loading/saving + - Test state transitions + - Validate VLM predicate evaluation + - Check observation consistency + +## Directory Structure + +The mock task creates this structure to simulate Spot's data: +``` +mock_env_data/test_two_cup_pick_place/ +├── images/ # Mock camera observations +│ ├── state_0/ # Initial state +│ │ ├── view1/ # Front view +│ │ │ ├── cam1_rgb.npy # Hand camera RGB +│ │ │ ├── cam1_depth.npy # Hand camera depth +│ │ │ ├── cam2_rgb.npy # Navigation camera RGB +│ │ │ └── metadata.yaml # What objects are visible/held +│ │ └── view2/ # Side view +│ │ └── cam1_rgb.npy # Another camera angle +│ └── state_1/ # Next state +│ └── ... +├── transitions/ # Task execution visualization +│ └── Transition Graph.html # Shows action sequence +└── plan.yaml # Task execution plan +``` + +## Tips for Mock Tasks + +1. **Task Definition**: + - Keep tasks focused and specific + - Define clear initial and goal states + - Only include necessary objects and predicates + +2. **Operators**: + - Use only operators that match Spot's capabilities + - Include all prerequisites (e.g., need to see object before picking) + - Consider physical constraints (e.g., reachability) + +3. **Mock Images**: + - Use realistic camera positions (hand camera, navigation camera) + - Include depth information for manipulation + - Match image content to state description + +4. **Testing**: + - Verify all state transitions are possible + - Check that images match state descriptions + - Validate gripper state and object tracking + - Test with different initial conditions + +## Environment Setup + +1. Configure the mock environment: +```python +utils.reset_config({ + "env": "mock_spot", + "approach": "oracle", + "num_test_tasks": 1, + "mock_env_data_dir": "path/to/mock_env_data", + "spot_vlm_eval_predicate": True +}) +``` + +2. Create an instance of MockSpotEnv: +```python +env = create_new_env("mock_spot") +``` + +## Task Creation + +Define objects, initial state, and goal state for a task: + +```python +# Create objects +robot = Object("robot", next(t for t in env.types if t.name == "robot")) +cube = Object("cube", next(t for t in env.types if t.name == "movable_object")) +target = Object("target", next(t for t in env.types if t.name == "immovable_object")) + +# Define initial state +init_atoms = { + GroundAtom(next(p for p in env.predicates if p.name == "HandEmpty"), [robot]), + GroundAtom(next(p for p in env.predicates if p.name == "InView"), [robot, cube]), + GroundAtom(next(p for p in env.predicates if p.name == "On"), [cube, target]) +} +init_state = State({ + robot: np.array([0.0, 0.0, 0.0]), # x,y,z position + cube: np.array([0.5, 0.5, 0.0]), + target: np.array([1.0, 1.0, 0.0]) +}, init_atoms) + +# Define goal +goal_atoms = { + GroundAtom(next(p for p in env.predicates if p.name == "HandEmpty"), [robot]), + GroundAtom(next(p for p in env.predicates if p.name == "On"), [cube, target]) +} + +# Create task +task = EnvironmentTask(init_state, goal_atoms) +``` + +The task creation process involves: + +1. Creating objects that will be part of the task, such as the robot, manipulable objects (e.g., cube), and target locations. The types of these objects should match the types defined in the environment. + +2. Defining the initial state of the task, which includes: + - The state of each object, represented as a dictionary mapping objects to their numeric properties (e.g., position) + - The initial set of true atoms, specifying the relationships and properties of objects at the start of the task + +3. Defining the goal state of the task, which is a set of atoms that should be true at the end of the task execution. These atoms represent the desired final state of the objects. + +4. Creating an `EnvironmentTask` instance that encapsulates the initial state and goal atoms, representing the complete task specification. + +By following this process, you can define custom tasks for the mock Spot environment, specifying the objects involved, their initial configuration, and the desired goal state. The planner will then attempt to find a sequence of actions that transforms the initial state into the goal state. + +## Perceiver Setup + +Initialize MockSpotPerceiver and reset it for a task: + +```python +# Create perceiver +perceiver = MockSpotPerceiver(data_dir="path/to/mock_env_data") + +# Initialize with task +perceiver.reset(task) + +# Verify observation +obs = perceiver.get_observation() +assert obs is not None +assert obs.vlm_predicates is not None +``` + +## Planning Pipeline + +1. Create approach, perceiver, execution monitor, and CogMan: +```python +# Create approach +options = get_gt_options(env.get_name()) +approach = create_approach("oracle", env.predicates, options, env.types, env.action_space, []) + +# Create execution monitor +exec_monitor = create_execution_monitor("trivial") + +# Create cogman +cogman = CogMan(approach, perceiver, exec_monitor) +``` + +2. Run planning: +```python +# Reset cogman with task +cogman.reset(task) + +# Run planning +metrics = _run_testing(env, cogman) +assert metrics["num_solved"] > 0 +``` + +## Action Wrapping + +The mock Spot environment uses a graph-based state representation where transitions are defined by operators. Each operator has a corresponding `ParameterizedOption` that creates actions with proper operator information. + +### Creating Actions with Operator Information + +1. Get options from the environment: +```python +# Get options from MockSpotGroundTruthOptionFactory +options = get_gt_options("mock_spot") + +# Each option corresponds to an operator and will create actions with proper extra_info +for option in options: + # When the option's policy is called, it creates an Action with: + # - A dummy action array (since we don't need real continuous control) + # - extra_info containing the operator name + action = option.policy(state, memory, objects, params) + # action.extra_info will have {"operator_name": option.name} +``` + +2. The environment's `step` method uses this operator information to: + - Look up the appropriate transition in the graph + - Update the state based on the operator's effects + - Return the next observation + +### Example: Pick and Place Task + +```python +# Create environment and get options +env = MockSpotEnv() +options = get_gt_options(env.get_name()) + +# Create approach with options +approach = create_approach("oracle", env.predicates, options, env.types, env.action_space, tasks) + +# Run episode +max_steps = 20 +(states, actions), solved, metrics = _run_episode( + cogman, + env, + "test", + 0, + max_steps, + do_env_reset=True, + terminate_on_goal_reached=True +) + +# Verify action sequence +action_names = [action.extra_info["operator_name"] for action in actions] +expected_operators = {"PickObjectFromTop", "DropObjectInside"} +assert all(name in expected_operators for name in action_names) +``` + +### Key Components + +1. `MockSpotGroundTruthOptionFactory` creates options that match the environment's operators: +```python +def get_options(cls, env_name: str, types: Dict[str, Type], + predicates: Dict[str, Predicate], + action_space: Box) -> Set[ParameterizedOption]: + # Creates one option per operator + # Each option's policy stores operator name in action's extra_info +``` + +2. Option policies create actions with operator information: +```python +def policy(state: State, memory: Dict, objects: Sequence[Object], + params: Array) -> Action: + # Create a dummy action array but store operator name in extra_info + arr = np.zeros(1, dtype=np.float32) + return Action(arr, extra_info={"operator_name": operator_name}) +``` + +3. The environment's `step` method uses this information to execute transitions: +```python +def step(self, action: Action) -> _MockSpotObservation: + # Get operator name from action + operator_name = action.extra_info["operator_name"] + # Look up transition in graph + next_state_id = self._str_transitions[self._current_state_id][operator_name] + # Update state and return observation +``` + +## Testing + +1. Set up test data using ManualMockEnvCreator: +```python +# Create test directory +test_dir = "mock_env_data/pick_place_test" +creator = ManualMockEnvCreator(test_dir) +``` + +2. Write unit tests: +```python +def test_mock_pick_and_place_planning(): + # Setup + test_dir = "mock_env_data/pick_place_test" + creator = ManualMockEnvCreator(test_dir) + setup_mock_environment(creator) + + # Create environment and perceiver + env = MockSpotEnv() + perceiver = MockSpotPerceiver(test_dir) + + # Create task + robot = Object("robot", robot_type) + block = Object("block", movable_type) + table = Object("table", surface_type) + + init_atoms = { + GroundAtom(predicates["HandEmpty"], [robot]), + GroundAtom(predicates["On"], [block, table]) + } + goal_atoms = { + GroundAtom(predicates["HandEmpty"], [robot]), + GroundAtom(predicates["On"], [block, target]) + } + task = Task(init_atoms, goal_atoms) + + # Run planning + approach = create_approach("oracle", predicates, options) + cogman = CogMan(approach, perceiver) + results = run_testing(env, cogman) + + # Verify results + assert results["num_solved"] == 1 + traj = results["trajectory"] + verify_trajectory_states(traj, expected_states) +``` + +3. Run integration tests: +```python +def test_mock_spot_pipeline(): + # Setup mock data + setup_mock_environment() + + # Run main with test config + args = [ + "--env", "mock_spot", + "--approach", "oracle", + "--seed", "0", + "--num_test_tasks", "1" + ] + results = run_main_with_args(args) + + # Verify results + verify_planning_results(results) + verify_execution_results(results) +``` + +## Verification + +Verify state transitions, plan correctness, and perception: + +- Check object positions +- Verify gripper state +- Validate transitions +- Verify action sequence +- Check predicate changes +- Validate goal achievement +- Validate observations +- Check image loading +- Verify object tracking + +## Execution Steps + +1. Set up environment: +```bash +# Create test directory +mkdir -p mock_env_data/pick_place_test +# Copy example images +cp tests/spot_utils/example_manual_mock_task_1/* mock_env_data/pick_place_test/ +``` + +2. Run unit tests: +```bash +pytest tests/spot_utils/test_mock_spot_planning.py -v +``` + +3. Run integration test: +```bash +python predicators/main.py --env mock_spot --approach oracle --seed 0 +``` + +4. Verify results: +- Check test output +- Examine generated plans +- Verify state transitions +- Review visualization output + +## Next Steps + +- Add more complex scenarios +- Test error cases +- Add belief space planning tests \ No newline at end of file diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/0/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/0/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/0/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/0/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/0/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/0/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/0/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/0/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/0/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/1/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/1/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/1/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/1/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/1/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/1/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/1/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/1/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/1/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/10/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/10/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/10/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/10/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/10/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/10/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/10/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/10/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/10/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/100/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/100/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/100/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/100/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/100/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/100/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/100/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/100/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/100/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/101/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/101/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/101/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/101/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/101/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/101/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/101/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/101/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/101/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/102/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/102/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/102/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/102/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/102/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/102/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/102/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/102/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/102/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/103/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/103/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/103/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/103/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/103/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/103/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/103/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/103/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/103/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/104/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/104/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/104/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/104/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/104/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/104/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/104/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/104/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/104/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/105/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/105/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/105/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/105/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/105/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/105/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/105/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/105/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/105/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/106/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/106/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/106/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/106/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/106/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/106/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/106/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/106/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/106/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/107/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/107/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/107/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/107/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/107/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/107/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/107/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/107/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/107/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/108/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/108/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/108/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/108/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/108/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/108/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/108/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/108/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/108/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/109/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/109/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/109/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/109/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/109/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/109/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/109/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/109/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/109/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/11/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/11/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/11/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/11/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/11/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/11/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/11/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/11/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/11/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/110/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/110/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/110/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/110/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/110/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/110/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/110/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/110/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/110/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/111/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/111/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/111/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/111/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/111/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/111/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/111/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/111/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/111/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/112/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/112/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/112/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/112/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/112/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/112/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/112/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/112/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/112/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/113/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/113/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/113/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/113/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/113/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/113/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/113/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/113/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/113/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/114/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/114/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/114/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/114/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/114/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/114/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/114/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/114/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/114/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/115/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/115/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/115/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/115/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/115/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/115/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/115/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/115/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/115/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/116/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/116/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/116/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/116/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/116/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/116/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/116/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/116/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/116/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/116/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/116/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/116/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/117/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/117/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/117/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/117/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/117/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/117/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/117/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/117/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/117/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/117/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/117/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/117/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/118/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/118/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/118/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/118/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/118/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/118/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/118/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/118/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/118/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/118/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/118/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/118/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/119/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/119/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/119/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/119/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/119/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/119/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/119/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/119/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/119/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/119/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/119/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/119/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/12/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/12/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/12/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/12/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/12/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/12/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/12/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/12/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/12/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/120/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/120/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/120/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/120/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/120/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/120/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/120/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/120/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/120/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/121/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/121/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/121/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/121/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/121/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/121/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/121/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/121/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/121/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/122/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/122/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/122/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/122/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/122/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/122/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/122/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/122/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/122/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/123/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/123/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/123/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/123/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/123/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/123/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/123/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/123/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/123/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/124/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/124/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/124/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/124/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/124/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/124/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/124/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/124/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/124/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/125/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/125/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/125/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/125/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/125/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/125/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/125/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/125/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/125/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/126/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/126/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/126/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/126/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/126/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/126/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/126/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/126/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/126/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/127/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/127/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/127/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/127/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/127/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/127/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/127/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/127/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/127/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/128/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/128/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/128/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/128/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/128/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/128/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/128/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/128/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/128/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/129/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/129/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/129/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/129/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/129/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/129/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/129/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/129/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/129/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/13/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/13/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/13/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/13/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/13/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/13/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/13/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/13/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/13/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/130/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/130/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/130/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/130/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/130/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/130/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/130/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/130/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/130/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/131/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/131/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/131/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/131/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/131/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/131/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/131/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/131/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/131/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/132/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/132/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/132/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/132/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/132/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/132/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/132/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/132/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/132/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/133/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/133/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/133/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/133/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/133/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/133/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/133/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/133/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/133/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/134/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/134/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/134/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/134/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/134/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/134/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/134/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/134/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/134/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/135/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/135/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/135/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/135/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/135/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/135/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/135/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/135/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/135/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/136/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/136/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/136/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/136/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/136/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/136/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/136/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/136/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/136/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/137/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/137/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/137/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/137/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/137/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/137/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/137/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/137/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/137/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/138/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/138/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/138/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/138/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/138/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/138/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/138/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/138/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/138/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/139/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/139/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/139/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/139/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/139/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/139/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/139/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/139/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/139/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/14/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/14/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/14/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/14/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/14/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/14/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/14/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/14/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/14/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/140/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/140/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/140/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/140/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/140/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/140/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/140/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/140/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/140/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/140/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/140/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/140/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/141/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/141/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/141/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/141/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/141/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/141/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/141/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/141/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/141/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/142/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/142/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/142/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/142/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/142/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/142/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/142/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/142/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/142/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/143/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/143/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/143/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/143/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/143/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/143/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/143/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/143/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/143/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/144/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/144/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/144/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/144/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/144/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/144/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/144/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/144/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/144/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/145/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/145/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/145/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/145/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/145/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/145/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/145/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/145/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/145/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/146/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/146/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/146/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/146/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/146/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/146/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/146/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/146/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/146/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/147/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/147/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/147/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/147/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/147/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/147/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/147/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/147/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/147/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/148/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/148/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/148/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/148/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/148/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/148/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/148/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/148/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/148/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/149/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/149/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/149/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/149/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/149/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/149/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/149/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/149/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/149/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/15/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/15/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/15/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/15/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/15/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/15/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/15/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/15/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/15/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/150/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/150/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/150/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/150/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/150/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/150/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/150/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/150/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/150/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/150/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/150/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/150/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/151/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/151/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/151/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/151/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/151/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/151/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/151/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/151/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/151/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/151/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/151/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/151/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/152/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/152/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/152/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/152/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/152/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/152/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/152/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/152/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/152/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/153/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/153/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/153/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/153/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/153/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/153/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/153/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/153/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/153/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/154/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/154/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/154/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/154/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/154/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/154/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/154/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/154/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/154/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/155/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/155/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/155/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/155/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/155/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/155/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/155/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/155/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/155/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/156/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/156/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/156/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/156/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/156/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/156/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/156/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/156/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/156/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/157/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/157/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/157/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/157/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/157/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/157/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/157/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/157/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/157/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/158/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/158/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/158/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/158/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/158/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/158/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/158/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/158/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/158/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/159/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/159/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/159/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/159/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/159/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/159/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/159/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/159/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/159/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/16/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/16/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/16/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/16/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/16/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/16/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/16/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/16/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/16/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/160/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/160/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/160/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/160/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/160/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/160/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/160/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/160/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/160/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/161/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/161/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/161/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/161/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/161/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/161/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/161/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/161/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/161/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/162/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/162/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/162/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/162/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/162/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/162/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/162/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/162/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/162/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/163/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/163/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/163/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/163/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/163/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/163/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/163/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/163/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/163/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/164/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/164/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/164/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/164/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/164/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/164/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/164/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/164/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/164/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/165/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/165/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/165/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/165/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/165/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/165/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/165/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/165/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/165/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/166/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/166/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/166/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/166/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/166/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/166/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/166/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/166/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/166/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/166/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/166/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/166/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/167/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/167/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/167/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/167/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/167/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/167/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/167/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/167/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/167/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/168/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/168/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/168/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/168/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/168/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/168/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/168/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/168/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/168/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/169/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/169/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/169/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/169/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/169/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/169/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/169/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/169/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/169/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/17/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/17/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/17/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/17/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/17/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/17/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/17/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/17/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/17/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/170/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/170/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/170/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/170/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/170/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/170/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/170/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/170/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/170/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/171/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/171/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/171/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/171/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/171/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/171/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/171/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/171/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/171/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/172/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/172/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/172/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/172/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/172/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/172/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/172/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/172/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/172/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/173/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/173/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/173/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/173/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/173/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/173/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/173/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/173/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/173/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/174/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/174/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/174/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/174/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/174/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/174/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/174/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/174/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/174/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/175/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/175/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/175/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/175/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/175/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/175/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/175/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/175/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/175/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/176/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/176/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/176/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/176/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/176/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/176/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/176/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/176/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/176/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/177/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/177/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/177/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/177/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/177/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/177/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/177/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/177/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/177/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/177/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/177/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/177/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/178/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/178/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/178/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/178/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/178/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/178/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/178/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/178/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/178/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/178/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/178/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/178/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/179/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/179/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/179/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/179/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/179/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/179/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/179/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/179/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/179/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/179/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/179/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/179/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/18/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/18/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/18/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/18/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/18/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/18/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/18/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/18/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/18/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/180/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/180/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/180/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/180/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/180/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/180/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/180/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/180/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/180/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/180/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/180/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/180/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/181/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/181/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/181/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/181/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/181/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/181/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/181/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/181/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/181/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/182/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/182/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/182/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/182/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/182/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/182/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/182/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/182/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/182/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/183/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/183/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/183/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/183/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/183/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/183/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/183/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/183/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/183/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/184/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/184/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/184/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/184/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/184/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/184/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/184/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/184/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/184/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/185/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/185/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/185/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/185/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/185/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/185/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/185/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/185/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/185/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/186/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/186/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/186/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/186/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/186/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/186/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/186/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/186/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/186/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/187/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/187/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/187/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/187/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/187/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/187/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/187/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/187/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/187/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/188/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/188/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/188/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/188/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/188/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/188/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/188/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/188/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/188/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/189/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/189/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/189/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/189/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/189/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/189/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/189/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/189/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/189/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/19/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/19/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/19/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/19/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/19/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/19/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/19/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/19/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/19/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/190/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/190/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/190/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/190/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/190/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/190/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/190/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/190/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/190/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/191/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/191/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/191/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/191/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/191/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/191/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/191/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/191/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/191/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/192/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/192/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/192/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/192/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/192/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/192/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/192/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/192/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/192/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/193/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/193/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/193/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/193/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/193/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/193/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/193/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/193/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/193/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/194/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/194/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/194/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/194/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/194/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/194/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/194/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/194/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/194/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/195/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/195/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/195/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/195/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/195/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/195/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/195/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/195/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/195/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/196/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/196/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/196/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/196/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/196/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/196/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/196/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/196/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/196/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/197/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/197/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/197/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/197/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/197/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/197/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/197/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/197/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/197/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/198/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/198/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/198/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/198/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/198/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/198/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/198/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/198/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/198/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/199/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/199/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/199/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/199/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/199/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/199/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/199/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/199/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/199/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/2/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/2/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/2/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/2/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/2/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/2/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/2/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/2/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/2/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/20/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/20/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/20/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/20/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/20/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/20/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/20/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/20/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/20/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/200/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/200/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/200/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/200/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/200/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/200/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/200/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/200/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/200/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/201/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/201/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/201/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/201/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/201/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/201/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/201/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/201/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/201/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/201/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/201/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/201/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/202/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/202/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/202/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/202/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/202/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/202/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/202/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/202/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/202/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/203/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/203/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/203/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/203/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/203/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/203/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/203/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/203/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/203/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/204/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/204/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/204/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/204/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/204/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/204/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/204/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/204/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/204/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/205/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/205/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/205/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/205/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/205/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/205/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/205/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/205/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/205/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/206/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/206/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/206/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/206/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/206/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/206/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/206/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/206/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/206/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/207/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/207/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/207/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/207/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/207/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/207/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/207/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/207/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/207/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/208/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/208/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/208/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/208/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/208/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/208/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/208/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/208/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/208/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/209/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/209/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/209/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/209/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/209/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/209/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/209/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/209/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/209/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/21/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/21/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/21/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/21/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/21/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/21/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/21/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/21/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/21/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/210/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/210/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/210/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/210/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/210/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/210/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/210/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/210/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/210/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/211/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/211/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/211/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/211/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/211/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/211/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/211/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/211/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/211/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/211/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/211/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/211/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/212/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/212/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/212/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/212/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/212/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/212/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/212/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/212/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/212/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/212/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/212/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/212/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/213/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/213/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/213/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/213/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/213/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/213/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/213/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/213/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/213/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/214/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/214/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/214/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/214/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/214/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/214/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/214/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/214/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/214/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/215/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/215/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/215/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/215/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/215/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/215/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/215/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/215/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/215/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/216/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/216/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/216/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/216/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/216/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/216/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/216/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/216/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/216/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/217/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/217/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/217/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/217/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/217/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/217/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/217/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/217/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/217/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/218/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/218/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/218/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/218/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/218/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/218/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/218/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/218/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/218/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/219/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/219/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/219/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/219/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/219/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/219/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/219/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/219/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/219/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/22/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/22/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/22/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/22/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/22/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/22/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/22/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/22/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/22/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/220/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/220/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/220/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/220/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/220/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/220/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/220/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/220/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/220/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/221/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/221/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/221/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/221/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/221/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/221/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/221/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/221/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/221/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/222/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/222/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/222/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/222/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/222/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/222/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/222/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/222/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/222/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/223/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/223/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/223/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/223/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/223/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/223/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/223/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/223/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/223/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/224/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/224/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/224/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/224/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/224/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/224/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/224/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/224/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/224/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/225/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/225/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/225/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/225/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/225/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/225/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/225/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/225/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/225/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/226/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/226/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/226/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/226/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/226/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/226/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/226/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/226/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/226/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/227/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/227/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/227/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/227/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/227/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/227/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/227/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/227/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/227/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/227/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/227/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/227/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/228/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/228/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/228/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/228/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/228/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/228/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/228/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/228/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/228/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/229/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/229/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/229/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/229/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/229/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/229/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/229/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/229/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/229/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/23/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/23/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/23/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/23/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/23/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/23/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/23/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/23/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/23/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/230/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/230/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/230/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/230/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/230/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/230/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/230/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/230/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/230/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/231/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/231/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/231/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/231/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/231/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/231/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/231/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/231/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/231/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/232/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/232/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/232/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/232/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/232/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/232/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/232/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/232/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/232/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/233/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/233/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/233/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/233/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/233/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/233/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/233/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/233/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/233/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/234/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/234/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/234/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/234/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/234/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/234/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/234/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/234/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/234/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/235/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/235/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/235/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/235/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/235/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/235/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/235/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/235/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/235/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/236/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/236/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/236/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/236/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/236/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/236/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/236/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/236/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/236/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/237/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/237/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/237/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/237/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/237/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/237/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/237/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/237/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/237/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/238/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/238/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/238/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/238/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/238/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/238/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/238/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/238/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/238/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/239/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/239/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/239/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/239/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/239/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/239/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/239/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/239/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/239/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/239/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/239/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/239/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/24/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/24/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/24/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/24/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/24/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/24/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/24/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/24/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/24/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/240/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/240/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/240/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/240/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/240/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/240/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/240/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/240/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/240/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/240/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/240/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/240/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/241/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/241/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/241/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/241/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/241/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/241/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/241/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/241/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/241/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/241/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/241/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/241/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/242/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/242/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/242/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/242/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/242/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/242/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/242/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/242/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/242/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/242/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/242/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/242/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/243/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/243/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/243/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/243/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/243/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/243/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/243/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/243/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/243/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/243/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/243/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/243/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/244/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/244/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/244/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/244/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/244/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/244/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/244/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/244/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/244/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/245/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/245/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/245/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/245/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/245/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/245/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/245/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/245/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/245/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/245/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/245/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/245/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/246/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/246/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/246/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/246/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/246/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/246/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/246/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/246/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/246/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/246/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/246/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/246/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/247/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/247/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/247/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/247/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/247/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/247/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/247/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/247/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/247/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/248/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/248/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/248/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/248/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/248/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/248/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/248/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/248/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/248/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/249/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/249/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/249/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/249/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/249/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/249/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/249/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/249/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/249/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/25/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/25/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/25/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/25/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/25/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/25/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/25/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/25/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/25/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/250/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/250/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/250/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/250/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/250/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/250/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/250/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/250/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/250/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/251/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/251/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/251/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/251/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/251/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/251/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/251/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/251/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/251/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/252/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/252/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/252/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/252/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/252/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/252/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/252/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/252/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/252/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/253/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/253/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/253/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/253/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/253/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/253/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/253/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/253/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/253/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/254/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/254/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/254/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/254/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/254/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/254/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/254/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/254/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/254/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/255/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/255/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/255/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/255/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/255/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/255/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/255/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/255/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/255/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/256/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/256/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/256/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/256/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/256/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/256/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/256/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/256/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/256/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/256/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/256/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/256/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/257/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/257/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/257/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/257/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/257/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/257/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/257/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/257/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/257/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/258/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/258/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/258/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/258/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/258/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/258/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/258/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/258/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/258/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/259/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/259/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/259/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/259/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/259/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/259/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/259/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/259/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/259/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/26/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/26/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/26/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/26/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/26/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/26/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/26/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/26/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/26/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/260/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/260/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/260/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/260/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/260/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/260/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/260/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/260/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/260/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/261/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/261/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/261/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/261/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/261/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/261/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/261/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/261/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/261/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/262/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/262/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/262/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/262/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/262/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/262/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/262/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/262/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/262/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/263/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/263/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/263/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/263/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/263/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/263/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/263/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/263/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/263/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/264/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/264/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/264/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/264/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/264/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/264/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/264/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/264/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/264/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/265/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/265/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/265/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/265/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/265/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/265/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/265/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/265/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/265/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/266/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/266/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/266/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/266/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/266/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/266/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/266/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/266/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/266/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/267/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/267/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/267/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/267/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/267/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/267/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/267/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/267/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/267/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/268/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/268/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/268/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/268/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/268/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/268/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/268/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/268/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/268/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/269/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/269/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/269/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/269/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/269/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/269/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/269/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/269/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/269/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/269/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/269/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/269/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/27/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/27/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/27/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/27/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/27/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/27/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/27/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/27/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/27/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/270/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/270/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/270/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/270/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/270/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/270/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/270/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/270/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/270/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/271/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/271/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/271/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/271/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/271/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/271/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/271/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/271/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/271/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/272/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/272/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/272/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/272/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/272/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/272/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/272/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/272/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/272/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/272/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/272/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/272/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/273/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/273/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/273/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/273/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/273/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/273/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/273/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/273/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/273/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/274/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/274/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/274/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/274/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/274/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/274/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/274/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/274/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/274/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/275/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/275/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/275/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/275/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/275/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/275/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/275/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/275/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/275/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/276/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/276/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/276/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/276/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/276/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/276/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/276/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/276/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/276/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/277/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/277/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/277/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/277/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/277/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/277/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/277/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/277/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/277/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/278/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/278/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/278/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/278/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/278/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/278/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/278/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/278/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/278/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/279/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/279/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/279/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/279/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/279/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/279/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/279/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/279/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/279/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/28/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/28/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/28/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/28/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/28/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/28/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/28/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/28/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/28/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/280/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/280/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/280/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/280/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/280/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/280/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/280/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/280/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/280/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/281/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/281/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/281/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/281/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/281/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/281/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/281/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/281/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/281/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/282/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/282/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/282/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/282/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/282/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/282/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/282/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/282/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/282/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/282/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/282/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/282/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/283/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/283/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/283/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/283/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/283/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/283/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/283/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/283/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/283/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/283/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/283/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/283/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/284/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/284/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/284/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/284/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/284/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/284/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/284/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/284/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/284/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/284/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/284/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/284/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/285/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/285/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/285/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/285/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/285/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/285/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/285/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/285/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/285/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/286/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/286/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/286/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/286/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/286/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/286/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/286/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/286/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/286/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/287/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/287/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/287/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/287/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/287/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/287/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/287/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/287/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/287/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/288/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/288/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/288/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/288/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/288/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/288/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/288/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/288/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/288/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/289/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/289/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/289/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/289/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/289/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/289/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/289/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/289/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/289/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/29/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/29/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/29/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/29/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/29/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/29/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/29/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/29/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/29/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/290/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/290/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/290/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/290/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/290/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/290/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/290/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/290/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/290/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/291/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/291/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/291/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/291/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/291/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/291/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/291/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/291/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/291/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/292/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/292/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/292/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/292/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/292/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/292/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/292/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/292/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/292/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/293/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/293/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/293/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/293/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/293/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/293/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/293/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/293/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/293/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/293/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/293/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/293/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/294/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/294/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/294/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/294/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/294/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/294/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/294/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/294/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/294/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/294/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/294/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/294/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/295/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/295/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/295/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/295/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/295/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/295/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/295/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/295/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/295/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/295/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/295/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/295/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/296/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/296/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/296/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/296/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/296/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/296/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/296/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/296/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/296/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/297/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/297/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/297/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/297/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/297/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/297/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/297/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/297/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/297/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/298/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/298/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/298/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/298/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/298/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/298/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/298/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/298/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/298/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/299/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/299/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/299/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/299/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/299/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/299/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/299/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/299/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/299/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/3/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/3/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/3/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/3/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/3/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/3/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/3/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/3/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/3/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/30/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/30/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/30/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/30/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/30/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/30/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/30/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/30/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/30/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/300/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/300/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/300/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/300/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/300/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/300/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/300/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/300/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/300/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/301/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/301/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/301/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/301/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/301/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/301/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/301/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/301/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/301/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/302/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/302/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/302/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/302/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/302/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/302/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/302/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/302/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/302/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/303/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/303/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/303/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/303/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/303/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/303/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/303/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/303/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/303/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/303/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/303/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/303/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/304/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/304/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/304/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/304/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/304/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/304/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/304/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/304/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/304/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/305/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/305/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/305/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/305/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/305/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/305/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/305/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/305/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/305/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/306/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/306/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/306/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/306/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/306/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/306/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/306/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/306/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/306/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/307/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/307/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/307/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/307/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/307/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/307/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/307/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/307/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/307/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/308/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/308/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/308/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/308/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/308/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/308/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/308/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/308/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/308/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/309/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/309/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/309/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/309/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/309/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/309/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/309/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/309/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/309/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/31/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/31/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/31/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/31/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/31/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/31/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/31/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/31/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/31/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/310/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/310/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/310/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/310/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/310/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/310/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/310/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/310/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/310/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/311/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/311/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/311/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/311/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/311/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/311/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/311/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/311/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/311/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/312/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/312/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/312/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/312/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/312/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/312/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/312/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/312/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/312/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/312/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/312/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/312/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/313/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/313/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/313/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/313/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/313/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/313/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/313/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/313/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/313/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/314/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/314/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/314/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/314/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/314/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/314/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/314/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/314/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/314/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/315/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/315/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/315/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/315/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/315/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/315/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/315/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/315/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/315/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/315/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/315/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/315/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/316/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/316/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/316/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/316/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/316/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/316/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/316/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/316/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/316/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/316/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/316/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/316/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/317/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/317/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/317/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/317/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/317/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/317/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/317/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/317/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/317/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/318/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/318/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/318/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/318/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/318/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/318/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/318/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/318/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/318/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/319/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/319/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/319/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/319/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/319/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/319/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/319/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/319/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/319/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/32/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/32/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/32/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/32/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/32/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/32/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/32/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/32/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/32/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/320/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/320/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/320/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/320/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/320/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/320/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/320/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/320/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/320/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/321/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/321/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/321/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/321/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/321/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/321/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/321/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/321/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/321/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/322/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/322/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/322/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/322/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/322/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/322/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/322/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/322/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/322/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/322/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/322/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/322/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/323/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/323/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/323/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/323/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/323/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/323/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/323/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/323/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/323/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/323/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/323/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/323/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/324/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/324/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/324/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/324/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/324/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/324/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/324/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/324/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/324/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/324/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/324/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/324/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/325/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/325/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/325/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/325/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/325/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/325/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/325/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/325/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/325/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/325/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/325/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/325/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/326/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/326/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/326/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/326/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/326/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/326/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/326/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/326/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/326/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/326/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/326/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/326/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/327/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/327/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/327/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/327/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/327/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/327/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/327/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/327/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/327/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/328/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/328/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/328/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/328/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/328/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/328/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/328/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/328/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/328/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/328/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/328/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/328/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/329/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/329/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/329/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/329/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/329/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/329/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/329/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/329/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/329/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/329/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/329/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/329/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/33/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/33/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/33/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/33/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/33/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/33/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/33/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/33/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/33/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/330/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/330/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/330/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/330/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/330/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/330/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/330/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/330/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/330/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/331/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/331/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/331/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/331/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/331/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/331/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/331/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/331/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/331/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/332/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/332/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/332/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/332/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/332/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/332/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/332/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/332/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/332/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/333/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/333/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/333/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/333/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/333/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/333/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/333/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/333/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/333/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/334/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/334/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/334/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/334/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/334/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/334/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/334/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/334/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/334/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/335/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/335/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/335/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/335/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/335/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/335/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/335/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/335/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/335/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/336/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/336/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/336/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/336/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/336/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/336/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/336/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/336/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/336/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/337/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/337/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/337/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/337/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/337/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/337/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/337/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/337/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/337/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/338/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/338/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/338/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/338/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/338/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/338/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/338/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/338/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/338/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/339/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/339/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/339/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/339/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/339/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/339/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/339/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/339/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/339/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/339/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/339/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/339/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/34/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/34/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/34/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/34/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/34/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/34/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/34/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/34/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/34/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/340/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/340/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/340/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/340/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/340/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/340/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/340/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/340/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/340/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/341/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/341/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/341/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/341/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/341/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/341/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/341/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/341/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/341/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/342/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/342/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/342/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/342/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/342/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/342/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/342/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/342/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/342/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/343/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/343/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/343/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/343/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/343/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/343/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/343/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/343/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/343/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/344/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/344/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/344/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/344/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/344/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/344/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/344/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/344/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/344/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/345/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/345/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/345/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/345/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/345/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/345/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/345/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/345/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/345/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/346/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/346/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/346/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/346/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/346/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/346/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/346/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/346/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/346/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/347/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/347/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/347/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/347/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/347/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/347/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/347/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/347/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/347/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/348/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/348/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/348/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/348/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/348/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/348/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/348/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/348/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/348/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/349/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/349/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/349/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/349/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/349/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/349/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/349/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/349/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/349/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/35/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/35/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/35/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/35/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/35/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/35/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/35/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/35/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/35/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/350/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/350/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/350/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/350/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/350/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/350/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/350/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/350/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/350/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/351/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/351/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/351/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/351/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/351/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/351/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/351/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/351/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/351/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/352/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/352/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/352/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/352/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/352/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/352/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/352/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/352/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/352/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/352/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/352/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/352/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/353/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/353/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/353/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/353/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/353/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/353/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/353/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/353/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/353/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/354/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/354/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/354/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/354/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/354/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/354/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/354/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/354/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/354/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/355/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/355/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/355/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/355/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/355/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/355/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/355/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/355/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/355/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/355/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/355/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/355/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/356/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/356/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/356/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/356/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/356/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/356/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/356/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/356/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/356/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/357/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/357/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/357/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/357/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/357/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/357/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/357/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/357/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/357/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/358/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/358/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/358/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/358/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/358/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/358/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/358/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/358/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/358/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/359/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/359/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/359/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/359/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/359/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/359/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/359/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/359/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/359/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/36/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/36/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/36/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/36/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/36/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/36/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/36/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/36/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/36/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/360/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/360/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/360/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/360/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/360/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/360/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/360/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/360/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/360/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/361/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/361/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/361/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/361/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/361/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/361/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/361/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/361/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/361/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/362/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/362/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/362/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/362/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/362/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/362/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/362/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/362/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/362/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/363/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/363/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/363/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/363/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/363/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/363/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/363/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/363/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/363/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/364/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/364/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/364/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/364/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/364/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/364/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/364/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/364/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/364/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/365/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/365/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/365/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/365/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/365/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/365/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/365/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/365/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/365/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/365/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/365/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/365/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/366/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/366/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/366/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/366/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/366/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/366/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/366/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/366/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/366/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/366/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/366/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/366/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/367/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/367/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/367/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/367/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/367/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/367/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/367/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/367/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/367/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/367/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/367/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/367/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/368/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/368/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/368/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/368/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/368/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/368/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/368/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/368/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/368/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/369/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/369/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/369/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/369/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/369/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/369/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/369/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/369/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/369/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/37/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/37/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/37/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/37/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/37/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/37/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/37/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/37/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/37/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/370/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/370/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/370/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/370/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/370/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/370/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/370/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/370/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/370/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/371/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/371/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/371/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/371/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/371/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/371/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/371/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/371/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/371/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/372/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/372/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/372/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/372/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/372/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/372/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/372/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/372/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/372/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/373/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/373/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/373/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/373/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/373/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/373/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/373/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/373/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/373/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/374/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/374/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/374/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/374/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/374/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/374/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/374/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/374/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/374/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/375/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/375/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/375/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/375/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/375/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/375/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/375/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/375/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/375/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/376/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/376/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/376/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/376/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/376/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/376/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/376/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/376/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/376/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/376/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/376/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/376/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/377/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/377/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/377/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/377/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/377/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/377/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/377/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/377/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/377/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/377/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/377/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/377/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/378/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/378/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/378/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/378/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/378/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/378/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/378/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/378/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/378/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/378/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/378/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/378/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/379/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/379/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/379/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/379/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/379/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/379/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/379/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/379/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/379/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/38/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/38/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/38/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/38/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/38/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/38/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/38/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/38/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/38/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/380/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/380/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/380/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/380/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/380/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/380/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/380/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/380/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/380/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/381/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/381/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/381/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/381/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/381/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/381/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/381/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/381/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/381/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/382/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/382/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/382/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/382/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/382/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/382/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/382/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/382/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/382/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/383/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/383/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/383/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/383/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/383/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/383/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/383/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/383/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/383/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/384/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/384/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/384/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/384/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/384/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/384/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/384/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/384/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/384/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/385/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/385/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/385/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/385/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/385/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/385/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/385/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/385/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/385/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/386/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/386/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/386/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/386/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/386/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/386/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/386/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/386/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/386/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/386/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/386/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/386/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/387/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/387/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/387/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/387/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/387/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/387/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/387/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/387/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/387/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/388/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/388/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/388/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/388/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/388/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/388/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/388/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/388/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/388/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/389/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/389/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/389/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/389/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/389/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/389/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/389/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/389/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/389/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/39/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/39/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/39/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/39/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/39/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/39/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/39/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/39/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/39/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/390/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/390/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/390/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/390/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/390/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/390/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/390/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/390/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/390/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/391/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/391/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/391/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/391/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/391/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/391/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/391/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/391/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/391/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/392/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/392/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/392/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/392/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/392/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/392/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/392/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/392/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/392/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/393/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/393/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/393/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/393/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/393/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/393/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/393/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/393/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/393/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/394/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/394/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/394/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/394/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/394/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/394/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/394/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/394/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/394/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/395/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/395/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/395/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/395/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/395/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/395/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/395/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/395/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/395/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/395/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/395/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/395/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/396/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/396/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/396/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/396/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/396/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/396/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/396/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/396/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/396/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/397/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/397/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/397/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/397/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/397/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/397/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/397/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/397/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/397/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/398/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/398/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/398/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/398/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/398/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/398/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/398/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/398/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/398/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/398/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/398/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/398/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/399/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/399/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/399/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/399/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/399/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/399/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/399/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/399/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/399/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/399/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/399/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/399/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/4/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/4/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/4/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/4/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/4/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/4/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/4/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/4/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/4/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/40/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/40/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/40/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/40/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/40/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/40/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/40/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/40/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/40/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/400/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/400/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/400/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/400/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/400/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/400/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/400/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/400/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/400/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/401/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/401/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/401/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/401/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/401/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/401/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/401/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/401/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/401/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/402/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/402/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/402/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/402/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/402/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/402/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/402/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/402/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/402/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/403/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/403/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/403/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/403/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/403/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/403/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/403/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/403/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/403/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/404/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/404/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..f4a7e8511f Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/404/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/404/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/404/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/404/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/404/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/404/state_metadata.yaml new file mode 100644 index 0000000000..672d40abb2 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/404/state_metadata.yaml @@ -0,0 +1,103 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/405/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/405/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/405/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/405/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/405/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/405/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/405/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/405/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/405/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/406/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/406/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/406/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/406/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/406/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/406/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/406/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/406/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/406/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/406/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/406/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/406/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/407/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/407/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/407/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/407/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/407/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/407/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/407/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/407/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/407/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/408/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/408/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/408/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/408/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/408/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/408/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/408/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/408/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/408/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/408/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/408/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/408/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/409/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/409/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/409/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/409/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/409/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/409/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/409/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/409/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/409/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/409/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/409/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/409/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/41/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/41/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/41/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/41/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/41/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/41/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/41/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/41/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/41/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/410/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/410/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/410/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/410/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/410/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/410/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/410/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/410/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/410/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/410/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/410/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/410/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/411/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/411/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/411/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/411/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/411/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/411/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/411/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/411/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/411/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/411/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/411/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/411/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/412/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/412/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/412/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/412/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/412/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/412/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/412/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/412/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/412/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/413/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/413/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/413/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/413/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/413/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/413/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/413/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/413/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/413/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/413/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/413/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/413/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/414/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/414/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/414/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/414/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/414/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/414/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/414/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/414/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/414/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/415/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/415/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/415/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/415/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/415/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/415/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/415/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/415/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/415/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/415/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/415/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/415/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/416/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/416/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/416/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/416/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/416/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/416/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/416/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/416/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/416/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/416/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/416/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/416/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/417/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/417/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/417/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/417/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/417/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/417/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/417/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/417/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/417/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/417/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/417/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/417/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/418/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/418/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/418/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/418/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/418/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/418/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/418/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/418/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/418/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/419/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/419/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/419/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/419/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/419/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/419/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/419/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/419/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/419/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/42/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/42/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/42/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/42/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/42/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/42/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/42/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/42/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/42/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/420/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/420/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/420/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/420/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/420/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/420/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/420/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/420/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/420/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/421/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/421/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/421/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/421/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/421/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/421/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/421/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/421/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/421/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/422/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/422/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/422/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/422/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/422/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/422/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/422/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/422/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/422/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/423/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/423/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/423/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/423/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/423/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/423/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/423/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/423/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/423/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/424/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/424/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/424/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/424/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/424/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/424/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/424/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/424/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/424/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/425/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/425/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/425/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/425/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/425/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/425/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/425/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/425/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/425/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/426/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/426/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/426/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/426/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/426/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/426/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/426/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/426/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/426/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/427/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/427/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/427/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/427/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/427/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/427/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/427/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/427/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/427/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/428/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/428/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/428/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/428/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/428/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/428/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/428/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/428/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/428/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/429/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/429/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/429/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/429/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/429/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/429/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/429/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/429/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/429/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/43/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/43/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/43/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/43/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/43/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/43/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/43/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/43/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/43/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/430/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/430/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/430/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/430/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/430/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/430/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/430/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/430/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/430/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/430/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/430/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/430/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/431/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/431/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/431/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/431/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/431/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/431/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/431/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/431/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/431/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/432/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/432/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/432/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/432/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/432/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/432/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/432/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/432/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/432/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/433/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/433/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/433/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/433/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/433/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/433/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/433/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/433/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/433/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/434/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/434/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/434/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/434/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/434/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/434/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/434/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/434/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/434/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/434/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/434/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/434/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/435/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/435/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/435/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/435/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/435/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/435/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/435/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/435/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/435/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/435/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/435/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/435/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/436/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/436/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/436/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/436/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/436/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/436/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/436/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/436/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/436/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/436/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/436/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/436/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/437/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/437/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/437/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/437/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/437/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/437/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/437/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/437/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/437/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/438/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/438/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/438/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/438/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/438/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/438/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/438/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/438/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/438/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/439/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/439/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/439/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/439/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/439/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/439/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/439/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/439/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/439/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/44/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/44/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/44/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/44/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/44/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/44/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/44/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/44/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/44/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/44/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/44/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/44/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/440/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/440/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/440/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/440/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/440/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/440/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/440/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/440/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/440/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/441/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/441/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/441/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/441/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/441/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/441/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/441/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/441/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/441/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/442/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/442/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/442/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/442/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/442/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/442/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/442/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/442/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/442/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/443/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/443/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/443/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/443/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/443/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/443/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/443/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/443/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/443/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/444/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/444/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/444/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/444/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/444/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/444/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/444/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/444/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/444/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/445/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/445/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/445/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/445/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/445/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/445/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/445/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/445/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/445/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/446/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/446/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/446/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/446/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/446/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/446/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/446/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/446/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/446/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/447/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/447/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/447/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/447/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/447/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/447/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/447/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/447/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/447/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/447/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/447/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/447/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/448/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/448/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/448/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/448/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/448/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/448/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/448/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/448/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/448/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/449/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/449/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/449/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/449/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/449/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/449/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/449/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/449/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/449/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/45/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/45/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/45/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/45/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/45/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/45/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/45/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/45/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/45/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/450/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/450/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/450/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/450/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/450/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/450/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/450/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/450/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/450/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/451/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/451/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/451/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/451/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/451/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/451/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/451/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/451/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/451/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/451/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/451/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/451/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/452/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/452/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/452/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/452/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/452/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/452/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/452/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/452/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/452/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/452/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/452/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/452/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/453/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/453/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/453/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/453/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/453/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/453/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/453/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/453/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/453/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/453/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/453/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/453/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/454/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/454/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/454/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/454/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/454/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/454/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/454/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/454/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/454/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/454/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/454/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/454/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/455/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/455/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/455/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/455/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/455/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/455/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/455/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/455/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/455/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/455/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/455/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/455/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/456/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/456/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/456/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/456/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/456/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/456/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/456/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/456/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/456/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/457/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/457/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/457/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/457/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/457/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/457/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/457/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/457/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/457/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/458/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/458/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/458/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/458/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/458/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/458/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/458/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/458/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/458/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/459/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/459/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/459/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/459/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/459/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/459/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/459/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/459/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/459/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/46/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/46/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/46/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/46/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/46/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/46/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/46/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/46/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/46/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/460/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/460/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/460/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/460/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/460/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/460/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/460/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/460/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/460/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/461/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/461/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/461/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/461/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/461/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/461/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/461/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/461/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/461/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/462/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/462/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/462/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/462/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/462/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/462/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/462/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/462/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/462/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/463/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/463/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/463/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/463/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/463/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/463/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/463/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/463/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/463/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/464/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/464/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/464/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/464/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/464/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/464/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/464/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/464/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/464/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/464/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/464/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/464/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/465/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/465/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/465/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/465/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/465/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/465/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/465/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/465/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/465/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/465/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/465/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/465/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/466/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/466/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/466/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/466/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/466/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/466/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/466/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/466/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/466/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/466/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/466/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/466/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/467/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/467/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/467/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/467/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/467/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/467/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/467/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/467/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/467/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/467/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/467/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/467/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/468/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/468/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/468/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/468/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/468/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/468/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/468/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/468/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/468/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/469/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/469/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/469/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/469/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/469/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/469/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/469/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/469/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/469/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/47/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/47/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/47/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/47/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/47/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/47/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/47/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/47/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/47/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/470/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/470/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/470/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/470/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/470/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/470/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/470/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/470/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/470/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/471/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/471/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/471/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/471/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/471/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/471/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/471/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/471/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/471/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/472/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/472/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/472/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/472/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/472/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/472/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/472/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/472/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/472/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/472/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/472/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/472/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/473/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/473/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/473/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/473/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/473/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/473/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/473/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/473/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/473/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/473/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/473/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/473/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/474/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/474/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/474/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/474/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/474/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/474/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/474/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/474/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/474/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/475/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/475/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/475/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/475/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/475/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/475/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/475/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/475/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/475/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/476/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/476/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/476/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/476/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/476/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/476/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/476/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/476/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/476/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/477/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/477/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/477/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/477/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/477/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/477/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/477/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/477/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/477/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/478/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/478/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/478/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/478/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/478/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/478/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/478/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/478/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/478/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/479/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/479/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/479/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/479/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/479/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/479/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/479/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/479/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/479/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/48/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/48/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/48/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/48/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/48/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/48/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/48/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/48/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/48/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/480/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/480/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/480/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/480/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/480/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/480/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/480/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/480/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/480/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/480/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/480/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/480/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/481/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/481/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/481/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/481/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/481/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/481/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/481/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/481/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/481/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/482/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/482/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/482/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/482/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/482/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/482/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/482/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/482/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/482/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/483/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/483/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/483/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/483/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/483/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/483/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/483/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/483/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/483/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/483/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/483/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/483/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/484/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/484/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/484/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/484/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/484/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/484/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/484/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/484/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/484/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/484/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/484/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/484/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/485/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/485/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/485/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/485/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/485/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/485/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/485/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/485/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/485/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/485/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/485/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/485/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/486/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/486/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/486/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/486/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/486/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/486/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/486/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/486/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/486/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/487/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/487/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/487/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/487/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/487/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/487/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/487/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/487/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/487/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/488/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/488/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/488/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/488/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/488/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/488/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/488/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/488/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/488/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/488/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/488/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/488/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/489/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/489/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/489/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/489/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/489/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/489/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/489/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/489/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/489/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/49/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/49/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/49/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/49/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/49/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/49/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/49/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/49/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/49/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/490/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/490/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/490/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/490/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/490/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/490/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/490/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/490/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/490/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/491/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/491/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/491/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/491/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/491/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/491/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/491/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/491/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/491/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/491/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/491/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/491/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/492/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/492/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/492/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/492/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/492/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/492/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/492/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/492/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/492/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/492/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/492/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/492/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/493/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/493/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..f4a7e8511f Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/493/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/493/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/493/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/493/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/493/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/493/state_metadata.yaml new file mode 100644 index 0000000000..672d40abb2 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/493/state_metadata.yaml @@ -0,0 +1,103 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/494/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/494/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/494/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/494/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/494/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/494/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/494/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/494/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/494/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/495/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/495/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/495/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/495/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/495/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/495/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/495/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/495/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/495/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/495/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/495/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/495/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/496/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/496/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/496/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/496/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/496/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/496/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/496/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/496/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/496/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/497/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/497/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/497/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/497/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/497/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/497/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/497/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/497/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/497/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/497/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/497/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/497/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/498/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/498/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/498/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/498/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/498/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/498/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/498/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/498/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/498/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/498/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/498/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/498/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/499/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/499/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/499/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/499/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/499/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/499/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/499/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/499/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/499/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/499/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/499/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/499/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/5/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/5/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/5/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/5/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/5/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/5/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/5/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/5/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/5/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/50/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/50/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/50/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/50/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/50/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/50/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/50/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/50/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/50/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/500/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/500/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/500/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/500/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/500/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/500/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/500/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/500/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/500/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/500/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/500/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/500/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/501/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/501/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/501/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/501/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/501/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/501/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/501/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/501/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/501/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/502/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/502/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/502/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/502/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/502/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/502/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/502/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/502/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/502/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/502/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/502/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/502/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/503/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/503/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/503/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/503/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/503/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/503/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/503/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/503/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/503/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/504/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/504/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/504/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/504/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/504/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/504/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/504/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/504/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/504/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/504/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/504/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/504/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/505/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/505/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/505/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/505/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/505/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/505/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/505/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/505/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/505/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/505/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/505/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/505/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/506/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/506/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/506/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/506/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/506/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/506/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/506/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/506/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/506/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/506/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/506/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/506/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/507/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/507/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/507/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/507/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/507/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/507/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/507/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/507/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/507/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/508/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/508/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/508/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/508/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/508/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/508/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/508/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/508/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/508/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/509/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/509/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/509/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/509/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/509/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/509/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/509/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/509/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/509/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/51/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/51/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/51/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/51/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/51/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/51/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/51/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/51/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/51/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/510/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/510/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/510/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/510/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/510/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/510/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/510/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/510/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/510/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/511/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/511/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/511/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/511/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/511/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/511/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/511/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/511/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/511/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/512/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/512/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/512/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/512/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/512/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/512/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/512/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/512/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/512/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/513/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/513/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/513/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/513/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/513/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/513/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/513/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/513/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/513/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/514/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/514/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/514/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/514/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/514/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/514/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/514/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/514/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/514/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/515/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/515/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/515/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/515/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/515/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/515/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/515/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/515/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/515/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/516/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/516/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/516/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/516/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/516/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/516/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/516/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/516/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/516/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/517/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/517/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/517/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/517/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/517/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/517/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/517/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/517/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/517/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/518/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/518/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/518/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/518/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/518/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/518/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/518/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/518/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/518/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/519/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/519/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/519/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/519/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/519/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/519/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/519/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/519/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/519/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/519/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/519/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/519/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/52/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/52/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/52/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/52/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/52/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/52/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/52/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/52/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/52/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/520/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/520/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/520/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/520/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/520/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/520/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/520/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/520/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/520/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/521/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/521/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/521/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/521/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/521/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/521/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/521/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/521/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/521/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/522/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/522/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/522/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/522/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/522/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/522/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/522/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/522/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/522/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/523/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/523/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/523/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/523/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/523/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/523/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/523/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/523/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/523/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/523/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/523/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/523/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/524/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/524/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/524/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/524/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/524/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/524/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/524/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/524/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/524/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/524/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/524/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/524/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/525/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/525/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/525/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/525/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/525/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/525/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/525/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/525/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/525/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/525/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/525/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/525/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/526/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/526/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/526/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/526/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/526/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/526/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/526/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/526/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/526/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/527/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/527/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/527/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/527/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/527/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/527/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/527/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/527/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/527/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/528/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/528/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/528/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/528/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/528/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/528/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/528/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/528/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/528/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/529/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/529/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/529/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/529/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/529/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/529/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/529/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/529/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/529/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/53/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/53/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/53/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/53/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/53/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/53/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/53/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/53/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/53/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/530/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/530/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/530/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/530/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/530/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/530/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/530/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/530/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/530/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/531/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/531/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/531/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/531/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/531/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/531/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/531/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/531/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/531/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/532/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/532/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/532/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/532/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/532/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/532/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/532/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/532/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/532/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/533/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/533/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/533/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/533/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/533/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/533/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/533/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/533/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/533/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/534/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/534/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/534/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/534/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/534/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/534/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/534/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/534/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/534/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/535/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/535/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/535/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/535/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/535/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/535/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/535/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/535/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/535/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/536/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/536/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/536/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/536/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/536/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/536/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/536/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/536/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/536/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/536/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/536/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/536/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/537/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/537/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/537/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/537/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/537/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/537/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/537/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/537/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/537/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/538/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/538/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/538/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/538/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/538/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/538/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/538/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/538/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/538/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/539/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/539/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/539/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/539/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/539/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/539/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/539/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/539/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/539/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/54/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/54/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/54/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/54/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/54/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/54/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/54/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/54/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/54/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/540/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/540/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/540/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/540/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/540/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/540/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/540/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/540/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/540/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/540/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/540/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/540/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/541/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/541/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/541/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/541/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/541/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/541/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/541/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/541/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/541/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/541/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/541/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/541/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/542/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/542/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/542/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/542/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/542/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/542/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/542/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/542/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/542/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/542/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/542/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/542/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/543/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/543/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/543/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/543/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/543/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/543/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/543/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/543/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/543/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/543/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/543/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/543/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/544/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/544/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/544/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/544/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/544/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/544/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/544/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/544/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/544/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/544/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/544/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/544/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/545/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/545/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/545/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/545/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/545/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/545/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/545/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/545/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/545/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/546/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/546/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/546/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/546/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/546/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/546/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/546/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/546/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/546/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/547/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/547/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/547/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/547/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/547/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/547/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/547/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/547/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/547/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/548/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/548/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/548/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/548/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/548/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/548/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/548/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/548/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/548/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/549/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/549/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/549/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/549/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/549/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/549/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/549/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/549/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/549/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/55/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/55/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/55/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/55/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/55/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/55/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/55/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/55/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/55/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/550/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/550/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/550/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/550/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/550/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/550/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/550/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/550/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/550/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/551/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/551/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/551/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/551/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/551/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/551/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/551/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/551/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/551/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/552/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/552/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/552/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/552/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/552/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/552/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/552/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/552/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/552/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/553/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/553/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/553/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/553/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/553/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/553/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/553/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/553/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/553/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/553/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/553/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/553/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/554/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/554/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/554/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/554/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/554/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/554/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/554/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/554/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/554/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/554/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/554/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/554/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/555/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/555/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/555/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/555/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/555/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/555/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/555/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/555/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/555/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/555/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/555/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/555/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/556/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/556/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/556/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/556/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/556/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/556/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/556/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/556/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/556/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/556/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/556/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/556/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/557/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/557/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/557/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/557/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/557/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/557/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/557/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/557/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/557/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/558/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/558/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/558/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/558/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/558/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/558/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/558/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/558/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/558/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/559/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/559/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/559/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/559/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/559/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/559/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/559/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/559/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/559/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/56/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/56/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/56/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/56/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/56/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/56/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/56/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/56/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/56/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/560/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/560/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/560/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/560/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/560/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/560/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/560/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/560/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/560/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/561/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/561/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/561/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/561/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/561/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/561/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/561/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/561/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/561/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/561/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/561/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/561/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/562/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/562/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/562/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/562/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/562/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/562/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/562/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/562/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/562/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/562/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/562/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/562/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/563/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/563/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/563/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/563/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/563/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/563/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/563/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/563/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/563/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/564/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/564/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/564/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/564/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/564/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/564/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/564/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/564/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/564/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/565/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/565/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/565/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/565/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/565/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/565/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/565/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/565/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/565/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/566/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/566/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/566/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/566/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/566/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/566/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/566/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/566/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/566/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/567/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/567/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/567/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/567/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/567/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/567/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/567/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/567/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/567/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/568/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/568/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/568/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/568/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/568/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/568/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/568/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/568/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/568/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/569/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/569/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/569/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/569/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/569/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/569/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/569/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/569/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/569/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/569/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/569/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/569/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/57/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/57/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/57/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/57/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/57/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/57/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/57/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/57/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/57/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/570/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/570/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/570/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/570/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/570/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/570/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/570/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/570/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/570/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/571/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/571/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/571/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/571/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/571/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/571/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/571/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/571/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/571/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/572/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/572/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/572/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/572/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/572/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/572/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/572/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/572/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/572/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/572/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/572/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/572/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/573/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/573/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/573/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/573/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/573/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/573/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/573/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/573/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/573/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/573/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/573/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/573/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/574/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/574/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/574/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/574/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/574/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/574/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/574/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/574/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/574/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/574/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/574/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/574/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/575/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/575/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/575/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/575/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/575/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/575/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/575/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/575/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/575/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/576/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/576/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/576/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/576/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/576/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/576/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/576/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/576/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/576/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/577/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/577/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/577/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/577/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/577/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/577/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/577/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/577/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/577/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/577/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/577/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/577/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/578/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/578/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/578/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/578/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/578/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/578/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/578/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/578/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/578/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/579/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/579/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/579/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/579/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/579/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/579/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/579/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/579/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/579/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/58/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/58/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/58/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/58/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/58/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/58/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/58/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/58/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/58/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/580/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/580/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/580/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/580/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/580/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/580/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/580/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/580/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/580/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/580/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/580/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/580/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/581/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/581/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/581/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/581/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/581/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/581/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/581/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/581/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/581/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/581/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/581/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/581/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/582/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/582/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..f4a7e8511f Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/582/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/582/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/582/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/582/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/582/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/582/state_metadata.yaml new file mode 100644 index 0000000000..672d40abb2 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/582/state_metadata.yaml @@ -0,0 +1,103 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/583/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/583/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/583/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/583/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/583/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/583/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/583/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/583/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/583/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/584/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/584/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/584/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/584/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/584/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/584/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/584/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/584/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/584/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/584/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/584/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/584/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/585/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/585/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/585/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/585/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/585/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/585/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/585/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/585/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/585/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/585/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/585/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/585/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/586/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/586/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..f4a7e8511f Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/586/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/586/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/586/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/586/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/586/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/586/state_metadata.yaml new file mode 100644 index 0000000000..672d40abb2 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/586/state_metadata.yaml @@ -0,0 +1,103 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/587/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/587/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/587/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/587/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/587/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/587/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/587/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/587/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/587/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/588/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/588/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/588/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/588/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/588/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/588/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/588/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/588/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/588/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/589/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/589/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/589/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/589/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/589/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/589/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/589/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/589/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/589/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/59/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/59/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/59/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/59/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/59/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/59/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/59/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/59/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/59/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/590/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/590/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/590/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/590/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/590/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/590/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/590/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/590/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/590/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/590/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/590/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/590/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/591/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/591/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/591/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/591/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/591/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/591/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/591/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/591/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/591/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/591/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/591/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/591/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/592/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/592/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..f4a7e8511f Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/592/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/592/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/592/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/592/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/592/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/592/state_metadata.yaml new file mode 100644 index 0000000000..672d40abb2 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/592/state_metadata.yaml @@ -0,0 +1,103 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/593/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/593/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/593/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/593/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/593/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/593/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/593/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/593/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/593/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/594/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/594/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/594/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/594/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/594/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/594/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/594/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/594/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/594/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/595/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/595/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/595/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/595/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/595/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/595/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/595/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/595/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/595/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/596/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/596/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/596/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/596/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/596/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/596/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/596/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/596/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/596/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/596/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/596/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/596/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/597/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/597/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/597/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/597/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/597/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/597/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/597/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/597/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/597/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/597/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/597/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/597/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/598/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/598/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/598/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/598/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/598/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/598/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/598/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/598/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/598/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/598/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/598/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/598/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/599/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/599/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/599/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/599/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/599/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/599/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/599/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/599/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/599/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/6/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/6/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/6/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/6/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/6/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/6/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/6/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/6/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/6/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/60/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/60/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/60/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/60/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/60/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/60/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/60/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/60/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/60/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/60/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/60/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/60/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/600/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/600/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/600/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/600/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/600/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/600/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/600/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/600/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/600/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/601/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/601/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/601/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/601/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/601/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/601/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/601/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/601/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/601/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/602/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/602/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/602/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/602/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/602/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/602/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/602/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/602/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/602/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/603/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/603/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/603/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/603/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/603/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/603/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/603/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/603/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/603/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/604/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/604/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/604/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/604/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/604/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/604/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/604/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/604/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/604/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/605/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/605/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/605/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/605/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/605/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/605/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/605/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/605/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/605/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/606/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/606/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/606/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/606/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/606/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/606/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/606/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/606/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/606/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/607/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/607/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/607/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/607/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/607/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/607/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/607/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/607/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/607/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/608/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/608/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/608/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/608/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/608/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/608/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/608/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/608/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/608/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/609/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/609/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/609/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/609/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/609/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/609/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/609/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/609/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/609/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/609/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/609/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/609/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/61/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/61/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/61/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/61/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/61/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/61/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/61/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/61/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/61/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/610/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/610/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/610/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/610/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/610/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/610/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/610/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/610/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/610/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/611/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/611/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/611/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/611/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/611/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/611/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/611/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/611/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/611/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/612/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/612/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/612/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/612/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/612/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/612/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/612/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/612/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/612/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/613/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/613/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/613/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/613/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/613/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/613/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/613/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/613/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/613/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/613/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/613/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/613/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/614/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/614/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/614/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/614/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/614/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/614/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/614/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/614/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/614/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/614/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/614/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/614/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/615/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/615/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/615/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/615/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/615/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/615/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/615/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/615/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/615/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/616/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/616/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/616/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/616/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/616/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/616/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/616/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/616/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/616/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/617/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/617/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/617/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/617/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/617/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/617/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/617/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/617/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/617/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/617/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/617/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/617/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/618/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/618/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/618/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/618/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/618/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/618/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/618/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/618/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/618/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/618/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/618/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/618/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/619/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/619/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/619/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/619/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/619/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/619/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/619/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/619/state_metadata.yaml new file mode 100644 index 0000000000..f7627c7578 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/619/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- green_cup +- container +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/62/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/62/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/62/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/62/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/62/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/62/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/62/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/62/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/62/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/620/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/620/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/620/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/620/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/620/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/620/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/620/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/620/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/620/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/620/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/620/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/620/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/621/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/621/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/621/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/621/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/621/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/621/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/621/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/621/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/621/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/621/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/621/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/621/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/622/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/622/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/622/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/622/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/622/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/622/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/622/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/622/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/622/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/623/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/623/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/623/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/623/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/623/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/623/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/623/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/623/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/623/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/624/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/624/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/624/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/624/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/624/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/624/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/624/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/624/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/624/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/624/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/624/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/624/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/625/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/625/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/625/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/625/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/625/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/625/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/625/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/625/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/625/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/626/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/626/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/626/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/626/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/626/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/626/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/626/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/626/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/626/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/627/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/627/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/627/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/627/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/627/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/627/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/627/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/627/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/627/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/628/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/628/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/628/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/628/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/628/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/628/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/628/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/628/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/628/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/629/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/629/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/629/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/629/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/629/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/629/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/629/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/629/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/629/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/629/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/629/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/629/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/63/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/63/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/63/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/63/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/63/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/63/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/63/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/63/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/63/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/630/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/630/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/630/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/630/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/630/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/630/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/630/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/630/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/630/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/631/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/631/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/631/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/631/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/631/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/631/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/631/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/631/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/631/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/632/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/632/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/632/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/632/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/632/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/632/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/632/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/632/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/632/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/633/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/633/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/633/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/633/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/633/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/633/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/633/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/633/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/633/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/633/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/633/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/633/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/634/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/634/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/634/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/634/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/634/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/634/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/634/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/634/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/634/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/634/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/634/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/634/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/635/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/635/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/635/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/635/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/635/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/635/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/635/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/635/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/635/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/636/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/636/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/636/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/636/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/636/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/636/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/636/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/636/state_metadata.yaml new file mode 100644 index 0000000000..61bb3f0641 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/636/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- container +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/637/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/637/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/637/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/637/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/637/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/637/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/637/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/637/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/637/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/637/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/637/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/637/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/638/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/638/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/638/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/638/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/638/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/638/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/638/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/638/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/638/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/638/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/638/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/638/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/639/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/639/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/639/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/639/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/639/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/639/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/639/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/639/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/639/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/639/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/639/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/639/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/64/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/64/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/64/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/64/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/64/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/64/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/64/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/64/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/64/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/640/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/640/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/640/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/640/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/640/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/640/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/640/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/640/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/640/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/640/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/640/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/640/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/641/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/641/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/641/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/641/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/641/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/641/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/641/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/641/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/641/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/642/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/642/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/642/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/642/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/642/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/642/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/642/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/642/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/642/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/643/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/643/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/643/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/643/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/643/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/643/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/643/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/643/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/643/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/644/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/644/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/644/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/644/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/644/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/644/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/644/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/644/state_metadata.yaml new file mode 100644 index 0000000000..4d39741202 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/644/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): true + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): false + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- red_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/645/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/645/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/645/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/645/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/645/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/645/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/645/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/645/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/645/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/645/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/645/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/645/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/646/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/646/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/646/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/646/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/646/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/646/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/646/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/646/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/646/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/646/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/646/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/646/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/647/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/647/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/647/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/647/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/647/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/647/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/647/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/647/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/647/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/647/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/647/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/647/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/648/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/648/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..df716bd7e9 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/648/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/648/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/648/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..c2da767c76 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/648/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/648/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/648/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/648/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/648/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/648/state_metadata.yaml new file mode 100644 index 0000000000..8a79e9e188 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/648/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): true + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): false + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): false + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/649/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/649/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/649/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/649/cam1.view1_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/649/cam1.view1_rgb.jpg new file mode 100644 index 0000000000..618d118ca6 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/649/cam1.view1_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/649/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/649/image_metadata.yaml new file mode 100644 index 0000000000..d373f11abe --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/649/image_metadata.yaml @@ -0,0 +1,10 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg +cam1.view1: + camera_name: cam1.view1 + depth_path: null + image_rot: null + rgb_path: cam1.view1_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/649/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/649/state_metadata.yaml new file mode 100644 index 0000000000..245234cc97 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/649/state_metadata.yaml @@ -0,0 +1,104 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): true + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): false + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- red_cup +- table +- robot +- green_cup +- container diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/65/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/65/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..0215f23340 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/65/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/65/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/65/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/65/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/65/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/65/state_metadata.yaml new file mode 100644 index 0000000000..887cd5409b --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/65/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): true + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): false + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): true + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): true + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- red_cup diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/650/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/650/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/650/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/650/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/650/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/650/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/650/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/650/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/650/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true + FitsInXY(red_cup,container): true + FitsInXY(red_cup,green_cup): false + FitsInXY(red_cup,red_cup): false + FitsInXY(red_cup,table): true + HandEmpty(robot): false + HasFlatTopSurface(container): true + HasFlatTopSurface(green_cup): false + HasFlatTopSurface(red_cup): false + HasFlatTopSurface(table): true + Holding(robot,container): false + Holding(robot,green_cup): false + Holding(robot,red_cup): true + InHandView(robot,container): false + InHandView(robot,green_cup): false + InHandView(robot,red_cup): false + InHandView(robot,table): false + InHandViewFromTop(robot,container): false + InHandViewFromTop(robot,green_cup): false + InHandViewFromTop(robot,red_cup): false + InHandViewFromTop(robot,table): false + Inside(container,container): false + Inside(container,green_cup): false + Inside(container,red_cup): false + Inside(green_cup,container): false + Inside(green_cup,green_cup): false + Inside(green_cup,red_cup): false + Inside(red_cup,container): false + Inside(red_cup,green_cup): false + Inside(red_cup,red_cup): false + IsPlaceable(container): true + IsPlaceable(green_cup): true + IsPlaceable(red_cup): true + Known_ContainerEmpty(container): false + Known_ContainerEmpty(green_cup): false + Known_ContainerEmpty(red_cup): false + NEq(container,container): false + NEq(container,green_cup): false + NEq(container,red_cup): false + NEq(container,table): true + NEq(green_cup,container): true + NEq(green_cup,green_cup): false + NEq(green_cup,red_cup): false + NEq(green_cup,table): true + NEq(red_cup,container): true + NEq(red_cup,green_cup): true + NEq(red_cup,red_cup): false + NEq(red_cup,table): true + NEq(table,container): false + NEq(table,green_cup): false + NEq(table,red_cup): false + NEq(table,table): false + NotBlocked(container): true + NotBlocked(green_cup): true + NotBlocked(red_cup): true + NotBlocked(table): false + NotHolding(robot,container): true + NotHolding(robot,green_cup): true + NotHolding(robot,red_cup): false + NotInsideAnyContainer(container): true + NotInsideAnyContainer(green_cup): true + NotInsideAnyContainer(red_cup): true + On(container,container): false + On(container,green_cup): false + On(container,red_cup): false + On(container,table): false + On(green_cup,container): false + On(green_cup,green_cup): false + On(green_cup,red_cup): false + On(green_cup,table): true + On(red_cup,container): false + On(red_cup,green_cup): false + On(red_cup,red_cup): false + On(red_cup,table): false + Reachable(robot,container): true + Reachable(robot,green_cup): true + Reachable(robot,red_cup): true + Reachable(robot,table): false + Unknown_ContainerEmpty(container): false + Unknown_ContainerEmpty(green_cup): true + Unknown_ContainerEmpty(red_cup): true +objects_in_hand: [] +objects_in_view: +- table +- green_cup +- robot diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/651/cam1.view0_rgb.jpg b/mock_env_data/MockSpotCupEmptiness/state_info/651/cam1.view0_rgb.jpg new file mode 100644 index 0000000000..d441e69d19 Binary files /dev/null and b/mock_env_data/MockSpotCupEmptiness/state_info/651/cam1.view0_rgb.jpg differ diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/651/image_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/651/image_metadata.yaml new file mode 100644 index 0000000000..90db05109a --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/651/image_metadata.yaml @@ -0,0 +1,5 @@ +cam1.view0: + camera_name: cam1.view0 + depth_path: null + image_rot: null + rgb_path: cam1.view0_rgb.jpg diff --git a/mock_env_data/MockSpotCupEmptiness/state_info/651/state_metadata.yaml b/mock_env_data/MockSpotCupEmptiness/state_info/651/state_metadata.yaml new file mode 100644 index 0000000000..0a36129818 --- /dev/null +++ b/mock_env_data/MockSpotCupEmptiness/state_info/651/state_metadata.yaml @@ -0,0 +1,102 @@ +atom_dict: {} +gripper_open: true +non_vlm_atom_dict: + BelieveFalse_ContainerEmpty(container): false + BelieveFalse_ContainerEmpty(green_cup): false + BelieveFalse_ContainerEmpty(red_cup): false + BelieveTrue_ContainerEmpty(container): false + BelieveTrue_ContainerEmpty(green_cup): false + BelieveTrue_ContainerEmpty(red_cup): false + FitsInXY(container,container): false + FitsInXY(container,green_cup): false + FitsInXY(container,red_cup): false + FitsInXY(container,table): false + FitsInXY(green_cup,container): true + FitsInXY(green_cup,green_cup): false + FitsInXY(green_cup,red_cup): false + FitsInXY(green_cup,table): true {"code":"deadline_exceeded","msg":"operation timed out"}