diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d3467a5a65d6b4bec144cb2240f0dec1ebbf6ebc --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__init__.py @@ -0,0 +1,2 @@ +from .scenes import * +from .tasks import * diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e37bb986316a66acbf2ac453bb0afaaa967c25bb Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__pycache__/sapien_env.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__pycache__/sapien_env.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf91c274dc19651242388e3540f1debf74eb6303 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__pycache__/sapien_env.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__pycache__/scene.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__pycache__/scene.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8bd41336b64c3de77ebc212f9b8dd0df6ccca7e2 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__pycache__/scene.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/minimal_template.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/minimal_template.py new file mode 100644 index 0000000000000000000000000000000000000000..fc52d4d2bdc134b0c7f1e5b100bb44fb351acac8 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/minimal_template.py @@ -0,0 +1,66 @@ +from typing import Any, Dict, Union + +import numpy as np +import sapien +import torch + +from mani_skill.agents.robots import Fetch, Panda +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.sensors.camera import CameraConfig +from mani_skill.utils import common, sapien_utils +from mani_skill.utils.registration import register_env +from mani_skill.utils.structs.types import SimConfig + + +@register_env("CustomEnv-v1", max_episode_steps=200) +class CustomEnv(BaseEnv): + + SUPPORTED_ROBOTS = ["panda", "fetch"] + agent: Union[Panda, Fetch] + + def __init__(self, *args, robot_uids="panda", robot_init_qpos_noise=0.02, **kwargs): + self.robot_init_qpos_noise = robot_init_qpos_noise + super().__init__(*args, robot_uids=robot_uids, **kwargs) + + @property + def _default_sim_config(self): + return SimConfig() + + @property + def _default_sensor_configs(self): + pose = sapien_utils.look_at(eye=[0.3, 0, 0.6], target=[-0.1, 0, 0.1]) + return [ + CameraConfig("base_camera", pose=pose, width=128, height=128, fov=np.pi / 2) + ] + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at([0.6, 0.7, 0.6], [0.0, 0.0, 0.35]) + return CameraConfig("render_camera", pose=pose, width=512, height=512, fov=1) + + def _load_agent(self, options: dict): + super()._load_agent(options, sapien.Pose(p=[0, 0, 0])) + + def _load_scene(self, options: dict): + pass + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + pass + + def evaluate(self): + return { + "success": torch.zeros(self.num_envs, device=self.device, dtype=bool), + "fail": torch.zeros(self.num_envs, device=self.device, dtype=bool), + } + + def _get_obs_extra(self, info: Dict): + return dict() + + def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict): + return torch.zeros(self.num_envs, device=self.device) + + def compute_normalized_dense_reward( + self, obs: Any, action: torch.Tensor, info: Dict + ): + max_reward = 1.0 + return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/sapien_env.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/sapien_env.py new file mode 100644 index 0000000000000000000000000000000000000000..2e0e5ac8a87efc39e0af4615557a6f3927e7c4bf --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/sapien_env.py @@ -0,0 +1,1357 @@ +import copy +import gc +import os +from functools import cached_property +from typing import Any, Dict, List, Optional, Sequence, Tuple, Union + +import dacite +import gymnasium as gym +import numpy as np +import sapien +import sapien.physx as physx +import sapien.render +import sapien.utils.viewer.control_window +import torch +from gymnasium.vector.utils import batch_space + +from mani_skill import PACKAGE_ASSET_DIR, logger +from mani_skill.agents import REGISTERED_AGENTS +from mani_skill.agents.base_agent import BaseAgent +from mani_skill.agents.multi_agent import MultiAgent +from mani_skill.envs.scene import ManiSkillScene +from mani_skill.envs.utils.observations import ( + parse_obs_mode_to_struct, + sensor_data_to_pointcloud, +) +from mani_skill.envs.utils.randomization.batched_rng import BatchedRNG +from mani_skill.envs.utils.system.backend import parse_sim_and_render_backend +from mani_skill.sensors.base_sensor import BaseSensor, BaseSensorConfig +from mani_skill.sensors.camera import ( + Camera, + CameraConfig, + parse_camera_configs, + update_camera_configs_from_dict, +) +from mani_skill.sensors.depth_camera import StereoDepthCamera, StereoDepthCameraConfig +from mani_skill.utils import common, gym_utils, sapien_utils +from mani_skill.utils.structs import Actor, Articulation +from mani_skill.utils.structs.pose import Pose +from mani_skill.utils.structs.types import Array, SimConfig +from mani_skill.utils.visualization.misc import tile_images +from mani_skill.viewer import create_viewer + + +class BaseEnv(gym.Env): + """Superclass for ManiSkill environments. + + Args: + num_envs: number of parallel environments to run. By default this is 1, which means a CPU simulation is used. If greater than 1, + then we initialize the GPU simulation setup. Note that not all environments are faster when simulated on the GPU due to limitations of + GPU simulations. For example, environments with many moving objects are better simulated by parallelizing across CPUs. + + obs_mode: observation mode to be used. Must be one of ("state", "state_dict", "none", "sensor_data", "rgb", "depth", "segmentation", "rgbd", "rgb+depth", "rgb+depth+segmentation", "rgb+segmentation", "depth+segmentation", "pointcloud") + The obs_mode is mostly for convenience to automatically optimize/setup all sensors/cameras for the given observation mode to render the correct data and try to ignore unecesary rendering. + For the most advanced use cases (e.g. you have 1 RGB only camera and 1 depth only camera) + + reward_mode: reward mode to use. Must be one of ("normalized_dense", "dense", "sparse", "none"). With "none" the reward returned is always 0 + + control_mode: control mode of the agent. + "*" represents all registered controllers, and the action space will be a dict. + + render_mode: render mode registered in @SUPPORTED_RENDER_MODES. + + shader_dir (Optional[str]): shader directory. Defaults to None. + Setting this will override the shader used for all cameras in the environment. This is legacy behavior kept for backwards compatibility. + The proper way to change the shaders used for cameras is to either change the environment code or pass in sensor_configs/human_render_camera_configs with the desired shaders. + + + Previously the options are "default", "rt", "rt-fast". "rt" means ray-tracing which results + in more photorealistic renders but is slow, "rt-fast" is a lower quality but faster version of "rt". + + enable_shadow (bool): whether to enable shadow for lights. Defaults to False. + + sensor_configs (dict): configurations of sensors to override any environment defaults. + If the key is one of sensor names (e.g. a camera), the config value will be applied to the corresponding sensor. + Otherwise, the value will be applied to all sensors (but overridden by sensor-specific values). For possible configurations + see the documentation see :doc:`the sensors documentation `. + + human_render_camera_configs (dict): configurations of human rendering cameras to override any environment defaults. Similar usage as @sensor_configs. + + viewer_camera_configs (dict): configurations of the viewer camera in the GUI to override any environment defaults. Similar usage as @sensor_configs. + + robot_uids (Union[str, BaseAgent, List[Union[str, BaseAgent]]]): List of robots to instantiate and control in the environment. + + sim_config (Union[SimConfig, dict]): Configurations for simulation if used that override the environment defaults. If given + a dictionary, it can just override specific attributes e.g. ``sim_config=dict(scene_config=dict(solver_iterations=25))``. If + passing in a SimConfig object, while typed, will override every attribute including the task defaults. Some environments + define their own recommended default sim configurations via the ``self._default_sim_config`` attribute that generally should not be + completely overriden. + + reconfiguration_freq (int): How frequently to call reconfigure when environment is reset via `self.reset(...)` + Generally for most users who are not building tasks this does not need to be changed. The default is 0, which means + the environment reconfigures upon creation, and never again. + + sim_backend (str): By default this is "auto". If sim_backend is "auto", then if ``num_envs == 1``, we use the PhysX CPU sim backend, otherwise + we use the PhysX GPU sim backend and automatically pick a GPU to use. + Can also be "physx_cpu" or "physx_cuda" to force usage of a particular sim backend. + To select a particular GPU to run the simulation on, you can pass "cuda:n" where n is the ID of the GPU, + similar to the way PyTorch selects GPUs. + Note that if this is "physx_cpu", num_envs can only be equal to 1. + + render_backend (str): By default this is "gpu". If render_backend is "gpu", then we auto select a GPU to render with. + It can be "cuda:n" where n is the ID of the GPU to render with. If this is "cpu", then we render on the CPU. + + parallel_in_single_scene (bool): By default this is False. If True, rendered images and the GUI will show all objects in one view. + This is only really useful for generating cool videos showing all environments at once but it is not recommended + otherwise as it slows down simulation and rendering. + + enhanced_determinism (bool): By default this is False and env resets will reset the episode RNG only when a seed / seed list is given. + If True, the environment will reset the episode RNG upon each reset regardless of whether a seed is provided. + Generally enhanced_determinisim is not needed and users are recommended to pass seeds into the env reset function instead. + """ + + # fmt: off + SUPPORTED_ROBOTS: List[Union[str, Tuple[str]]] = None + """Override this to enforce which robots or tuples of robots together are supported in the task. During env creation, + setting robot_uids auto loads all desired robots into the scene, but not all tasks are designed to support some robot setups""" + SUPPORTED_OBS_MODES = ("state", "state_dict", "none", "sensor_data", "any_textures", "pointcloud") + """The string observation modes the environment supports. Note that "none" and "any_texture" are special keys. none indicates no observation data is generated. + "any_texture" indicates that any combination of image textures generated by cameras are supported e.g. rgb+depth, normal+segmentation, albedo+rgb+depth etc. + For a full list of supported textures see """ + SUPPORTED_REWARD_MODES = ("normalized_dense", "dense", "sparse", "none") + SUPPORTED_RENDER_MODES = ("human", "rgb_array", "sensors", "all") + """The supported render modes. Human opens up a GUI viewer. rgb_array returns an rgb array showing the current environment state. + sensors returns an rgb array but only showing all data collected by sensors as images put together""" + + metadata = {"render_modes": SUPPORTED_RENDER_MODES} + + scene: ManiSkillScene = None + """the main scene, which manages all sub scenes. In CPU simulation there is only one sub-scene""" + + agent: BaseAgent + + action_space: gym.Space + """the batched action space of the environment, which is also the action space of the agent""" + single_action_space: gym.Space + """the unbatched action space of the environment""" + + _sensors: Dict[str, BaseSensor] + """all sensors configured in this environment""" + _sensor_configs: Dict[str, BaseSensorConfig] + """all sensor configurations parsed from self._sensor_configs and agent._sensor_configs""" + _agent_sensor_configs: Dict[str, BaseSensorConfig] + """all agent sensor configs parsed from agent._sensor_configs""" + _human_render_cameras: Dict[str, Camera] + """cameras used for rendering the current environment retrievable via `env.render_rgb_array()`. These are not used to generate observations""" + _default_human_render_camera_configs: Dict[str, CameraConfig] + """all camera configurations for cameras used for human render""" + _human_render_camera_configs: Dict[str, CameraConfig] + """all camera configurations parsed from self._human_render_camera_configs""" + + _hidden_objects: List[Union[Actor, Articulation]] = [] + """list of objects that are hidden during rendering when generating visual observations / running render_cameras()""" + + _main_rng: np.random.RandomState = None + """main rng generator that generates episode seed sequences. For internal use only""" + _batched_main_rng: BatchedRNG = None + """the batched main RNG that generates episode seed sequences. For internal use only""" + _main_seed: List[int] = None + """main seed list for _main_rng and _batched_main_rng. _main_rng uses _main_seed[0]. For internal use only""" + _episode_rng: np.random.RandomState = None + """the numpy RNG that you can use to generate random numpy data. It is not recommended to use this. Instead use the _batched_episode_rng which helps ensure GPU and CPU simulation generate the same data with the same seeds.""" + _batched_episode_rng: BatchedRNG = None + """the recommended batched episode RNG to generate random numpy data consistently between single and parallel environments""" + _episode_seed: np.ndarray = None + """episode seed list for _episode_rng and _batched_episode_rng. _episode_rng uses _episode_seed[0].""" + _batched_rng_backend = "numpy:random_state" + """the backend to use for the batched RNG""" + _enhanced_determinism: bool = False + """whether to reset the episode RNG upon each reset regardless of whether a seed is provided""" + + _parallel_in_single_scene: bool = False + """whether all objects are placed in one scene for the purpose of rendering all objects together instead of in parallel""" + + _sim_device: sapien.Device = None + """the sapien device object the simulation runs on""" + + _render_device: sapien.Device = None + """the sapien device object the renderer runs on""" + + _viewer: Union[sapien.utils.Viewer, None] = None + + _sample_video_link: Optional[str] = None + """a link to a sample video of the task. This is mostly used for automatic documentation generation""" + + def __init__( + self, + num_envs: int = 1, + obs_mode: Optional[str] = None, + reward_mode: Optional[str] = None, + control_mode: Optional[str] = None, + render_mode: Optional[str] = None, + shader_dir: Optional[str] = None, + enable_shadow: bool = False, + sensor_configs: Optional[dict] = dict(), + human_render_camera_configs: Optional[dict] = dict(), + viewer_camera_configs: Optional[dict] = dict(), + robot_uids: Union[str, BaseAgent, List[Union[str, BaseAgent]]] = None, + sim_config: Union[SimConfig, dict] = dict(), + reconfiguration_freq: Optional[int] = None, + sim_backend: str = "auto", + render_backend: str = "gpu", + parallel_in_single_scene: bool = False, + enhanced_determinism: bool = False, + ): + self._enhanced_determinism = enhanced_determinism + + self.num_envs = num_envs + self.reconfiguration_freq = reconfiguration_freq if reconfiguration_freq is not None else 0 + self._reconfig_counter = 0 + if shader_dir is not None: + logger.warn("shader_dir argument will be deprecated after ManiSkill v3.0.0 official release. Please use sensor_configs/human_render_camera_configs to set shaders.") + sensor_configs |= dict(shader_pack=shader_dir) + human_render_camera_configs |= dict(shader_pack=shader_dir) + viewer_camera_configs |= dict(shader_pack=shader_dir) + self._custom_sensor_configs = sensor_configs + self._custom_human_render_camera_configs = human_render_camera_configs + self._custom_viewer_camera_configs = viewer_camera_configs + self._parallel_in_single_scene = parallel_in_single_scene + self.robot_uids = robot_uids + if isinstance(robot_uids, tuple) and len(robot_uids) == 1: + self.robot_uids = robot_uids[0] + if self.SUPPORTED_ROBOTS is not None: + if self.robot_uids not in self.SUPPORTED_ROBOTS: + logger.warn(f"{self.robot_uids} is not in the task's list of supported robots. Code may not run as intended") + + if sim_backend == "auto": + if num_envs > 1: + sim_backend = "physx_cuda" + else: + sim_backend = "physx_cpu" + self.backend = parse_sim_and_render_backend(sim_backend, render_backend) + # determine the sim and render devices + self.device = self.backend.device + self._sim_device = self.backend.sim_device + self._render_device = self.backend.render_device + if self.device.type == "cuda": + if not physx.is_gpu_enabled(): + physx.enable_gpu() + + # raise a number of nicer errors + if sim_backend == "cpu" and num_envs > 1: + raise RuntimeError("""Cannot set the sim backend to 'cpu' and have multiple environments. + If you want to do CPU sim backends and have environment vectorization you must use multi-processing across CPUs. + This can be done via the gymnasium's AsyncVectorEnv API""") + + if shader_dir is not None: + if "rt" == shader_dir[:2]: + if num_envs > 1 and parallel_in_single_scene == False: + raise RuntimeError("""Currently you cannot run ray-tracing on more than one environment in a single process""") + + assert not parallel_in_single_scene or (obs_mode not in ["sensor_data", "pointcloud", "rgb", "depth", "rgbd"]), \ + "Parallel rendering from parallel cameras is only supported when the gui/viewer is not used. parallel_in_single_scene must be False if using parallel rendering. If True only state based observations are supported." + + if isinstance(sim_config, SimConfig): + sim_config = sim_config.dict() + merged_gpu_sim_config = self._default_sim_config.dict() + common.dict_merge(merged_gpu_sim_config, sim_config) + self.sim_config = dacite.from_dict(data_class=SimConfig, data=merged_gpu_sim_config, config=dacite.Config(strict=True)) + """the final sim config after merging user overrides with the environment default""" + physx.set_gpu_memory_config(**self.sim_config.gpu_memory_config.dict()) + sapien.render.set_log_level(os.getenv("MS_RENDERER_LOG_LEVEL", "warn")) + + # Set simulation and control frequency + self._sim_freq = self.sim_config.sim_freq + self._control_freq = self.sim_config.control_freq + assert self._sim_freq % self._control_freq == 0, f"sim_freq({self._sim_freq}) is not divisible by control_freq({self._control_freq})." + self._sim_steps_per_control = self._sim_freq // self._control_freq + + # Observation mode + if obs_mode is None: + obs_mode = self.SUPPORTED_OBS_MODES[0] + if obs_mode not in self.SUPPORTED_OBS_MODES: + # we permit any combination of visual observation textures e.g. rgb+normal, depth+segmentation, etc. + if "any_textures" in self.SUPPORTED_OBS_MODES: + # the parse_visual_obs_mode_to_struct will check if the textures requested are valid + pass + else: + raise NotImplementedError(f"Unsupported obs mode: {obs_mode}. Must be one of {self.SUPPORTED_OBS_MODES}") + self._obs_mode = obs_mode + self.obs_mode_struct = parse_obs_mode_to_struct(self._obs_mode) + """dataclass describing what observation data is being requested by the user, detailing if state data is requested and what visual data is requested""" + + # Reward mode + if reward_mode is None: + reward_mode = self.SUPPORTED_REWARD_MODES[0] + if reward_mode not in self.SUPPORTED_REWARD_MODES: + raise NotImplementedError("Unsupported reward mode: {}".format(reward_mode)) + self._reward_mode = reward_mode + + # Control mode + self._control_mode = control_mode + # TODO(jigu): Support dict action space + if control_mode == "*": + raise NotImplementedError("Multiple controllers are not supported yet.") + + # Render mode + self.render_mode = render_mode + self._viewer = None + + # Lighting + self.enable_shadow = enable_shadow + + # Use a fixed (main) seed to enhance determinism + self._main_seed = None + self._set_main_rng([2022 + i for i in range(self.num_envs)]) + self._elapsed_steps = ( + torch.zeros(self.num_envs, device=self.device, dtype=torch.int32) + ) + obs, _ = self.reset(seed=[2022 + i for i in range(self.num_envs)], options=dict(reconfigure=True)) + + self._init_raw_obs = common.to_cpu_tensor(obs) + """the raw observation returned by the env.reset (a cpu torch tensor/dict of tensors). Useful for future observation wrappers to use to auto generate observation spaces""" + self._init_raw_state = common.to_cpu_tensor(self.get_state_dict()) + """the initial raw state returned by env.get_state. Useful for reconstructing state dictionaries from flattened state vectors""" + + if self.agent is not None: + self.action_space = self.agent.action_space + """the batched action space of the environment, which is also the action space of the agent""" + self.single_action_space = self.agent.single_action_space + """the unbatched action space of the environment""" + self._orig_single_action_space = copy.deepcopy(self.single_action_space) + """the original unbatched action space of the environment""" + else: + self.action_space = None + # initialize the cached properties + self.single_observation_space + self.observation_space + + def update_obs_space(self, obs: torch.Tensor): + """A convenient function to auto generate observation spaces if you modify them. + Call this function if you modify the observations returned by env.step and env.reset via an observation wrapper. + + The recommended way to use this is in a observation wrapper is as so + + .. code-block:: python + + import gymnasium as gym + from mani_skill.envs.sapien_env import BaseEnv + class YourObservationWrapper(gym.ObservationWrapper): + def __init__(self, env): + super().__init__(env) + self.base_env.update_obs_space(self.observation(self.base_env._init_raw_obs)) + @property + def base_env(self) -> BaseEnv: + return self.env.unwrapped + def observation(self, obs): + # your code for transforming the observation + """ + self._init_raw_obs = obs + del self.single_observation_space + del self.observation_space + self.single_observation_space + self.observation_space + + @cached_property + def single_observation_space(self) -> gym.Space: + """the unbatched observation space of the environment""" + return gym_utils.convert_observation_to_space(common.to_numpy(self._init_raw_obs), unbatched=True) + + @cached_property + def observation_space(self) -> gym.Space: + """the batched observation space of the environment""" + return batch_space(self.single_observation_space, n=self.num_envs) + + @property + def gpu_sim_enabled(self): + """Whether the gpu simulation is enabled.""" + return self.scene.gpu_sim_enabled + + @property + def _default_sim_config(self): + return SimConfig() + def _load_agent(self, options: dict, initial_agent_poses: Optional[Union[sapien.Pose, Pose]] = None): + agents = [] + robot_uids = self.robot_uids + if not isinstance(initial_agent_poses, list): + initial_agent_poses = [initial_agent_poses] + if robot_uids == "none" or robot_uids == ("none", ): + self.agent = None + return + if robot_uids is not None: + if not isinstance(robot_uids, tuple): + robot_uids = [robot_uids] + for i, robot_uid in enumerate(robot_uids): + if isinstance(robot_uid, type(BaseAgent)): + agent_cls = robot_uid + else: + if robot_uid not in REGISTERED_AGENTS: + raise RuntimeError( + f"Agent {robot_uid} not found in the dict of registered agents. If the id is not a typo then make sure to apply the @register_agent() decorator." + ) + agent_cls = REGISTERED_AGENTS[robot_uid].agent_cls + agent: BaseAgent = agent_cls( + self.scene, + self._control_freq, + self._control_mode, + agent_idx=i if len(robot_uids) > 1 else None, + initial_pose=initial_agent_poses[i] if initial_agent_poses is not None else None, + ) + agents.append(agent) + if len(agents) == 1: + self.agent = agents[0] + else: + self.agent = MultiAgent(agents) + + @property + def _default_sensor_configs( + self, + ) -> Union[ + BaseSensorConfig, Sequence[BaseSensorConfig], Dict[str, BaseSensorConfig] + ]: + """Add default (non-agent) sensors to the environment by returning sensor configurations. These can be overriden by the user at + env creation time""" + return [] + @property + def _default_human_render_camera_configs( + self, + ) -> Union[ + CameraConfig, Sequence[CameraConfig], Dict[str, CameraConfig] + ]: + """Add default cameras for rendering when using render_mode='rgb_array'. These can be overriden by the user at env creation time """ + return [] + + @property + def _default_viewer_camera_configs( + self, + ) -> CameraConfig: + """Default configuration for the viewer camera, controlling shader, fov, etc. By default if there is a human render camera called "render_camera" then the viewer will use that camera's pose.""" + return CameraConfig(uid="viewer", pose=sapien.Pose([0, 0, 1]), width=1920, height=1080, shader_pack="default", near=0.0, far=1000, fov=np.pi / 2) + + @property + def sim_freq(self) -> int: + """The frequency (Hz) of the simulation loop""" + return self._sim_freq + + @property + def control_freq(self): + """The frequency (Hz) of the control loop""" + return self._control_freq + + @property + def sim_timestep(self): + """The timestep (dt) of the simulation loop""" + return 1.0 / self._sim_freq + + @property + def control_timestep(self): + """The timestep (dt) of the control loop""" + return 1.0 / self._control_freq + + @property + def control_mode(self) -> str: + """The control mode of the agent""" + return self.agent.control_mode + + @property + def elapsed_steps(self) -> torch.Tensor: + """The number of steps that have elapsed in the environment""" + return self._elapsed_steps + + # ---------------------------------------------------------------------------- # + # Observation + # ---------------------------------------------------------------------------- # + @property + def obs_mode(self) -> str: + """The current observation mode. This affects the observation returned by env.get_obs()""" + return self._obs_mode + + def get_obs(self, info: Optional[Dict] = None): + """ + Return the current observation of the environment. User may call this directly to get the current observation + as opposed to taking a step with actions in the environment. + + Note that some tasks use info of the current environment state to populate the observations to avoid having to + compute slow operations twice. For example a state based observation may wish to include a boolean indicating + if a robot is grasping an object. Computing this boolean correctly is slow, so it is preferable to generate that + data in the info object by overriding the `self.evaluate` function. + + Args: + info (Dict): The info object of the environment. Generally should always be the result of `self.get_info()`. + If this is None (the default), this function will call `self.get_info()` itself + """ + if info is None: + info = self.get_info() + if self._obs_mode == "none": + # Some cases do not need observations, e.g., MPC + return dict() + elif self._obs_mode == "state": + state_dict = self._get_obs_state_dict(info) + obs = common.flatten_state_dict(state_dict, use_torch=True, device=self.device) + elif self._obs_mode == "state_dict": + obs = self._get_obs_state_dict(info) + elif self._obs_mode == "pointcloud": + obs = self._get_obs_with_sensor_data(info) + obs = sensor_data_to_pointcloud(obs, self._sensors) + elif self._obs_mode == "sensor_data": + # return raw texture data dependent on choice of shader + obs = self._get_obs_with_sensor_data(info, apply_texture_transforms=False) + else: + obs = self._get_obs_with_sensor_data(info) + + # flatten parts of the state observation if requested + if self.obs_mode_struct.state: + if isinstance(obs, dict): + data = dict(agent=obs.pop("agent"), extra=obs.pop("extra")) + obs["state"] = common.flatten_state_dict(data, use_torch=True, device=self.device) + return obs + + def _get_obs_state_dict(self, info: Dict): + """Get (ground-truth) state-based observations.""" + return dict( + agent=self._get_obs_agent(), + extra=self._get_obs_extra(info), + ) + + def _get_obs_agent(self): + """Get observations about the agent's state. By default it is proprioceptive observations which include qpos and qvel. + Controller state is also included although most default controllers do not have any state.""" + return self.agent.get_proprioception() + + def _get_obs_extra(self, info: Dict): + """Get task-relevant extra observations. Usually defined on a task by task basis""" + return dict() + + def capture_sensor_data(self): + """Capture data from all sensors (non-blocking)""" + for sensor in self._sensors.values(): + sensor.capture() + + def get_sensor_images(self) -> Dict[str, Dict[str, torch.Tensor]]: + """Get image (RGB) visualizations of what sensors currently sense. This function calls self._get_obs_sensor_data() internally which automatically hides objects and updates the render""" + return self.scene.get_sensor_images(self._get_obs_sensor_data()) + + def get_sensor_params(self) -> Dict[str, Dict[str, torch.Tensor]]: + """Get all sensor parameters.""" + params = dict() + for name, sensor in self._sensors.items(): + params[name] = sensor.get_params() + return params + + def _get_obs_sensor_data(self, apply_texture_transforms: bool = True) -> dict: + """get only data from sensors. Auto hides any objects that are designated to be hidden""" + for obj in self._hidden_objects: + obj.hide_visual() + self.scene.update_render(update_sensors=True, update_human_render_cameras=False) + self.capture_sensor_data() + sensor_obs = dict() + for name, sensor in self.scene.sensors.items(): + if isinstance(sensor, Camera): + if self.obs_mode in ["state", "state_dict"]: + # normally in non visual observation modes we do not render sensor observations. But some users may want to render sensor data for debugging or various algorithms + sensor_obs[name] = sensor.get_obs(position=False, segmentation=False, apply_texture_transforms=apply_texture_transforms) + else: + sensor_obs[name] = sensor.get_obs( + rgb=self.obs_mode_struct.visual.rgb, + depth=self.obs_mode_struct.visual.depth, + position=self.obs_mode_struct.visual.position, + segmentation=self.obs_mode_struct.visual.segmentation, + normal=self.obs_mode_struct.visual.normal, + albedo=self.obs_mode_struct.visual.albedo, + apply_texture_transforms=apply_texture_transforms + ) + # explicitly synchronize and wait for cuda kernels to finish + # this prevents the GPU from making poor scheduling decisions when other physx code begins to run + torch.cuda.synchronize() + return sensor_obs + def _get_obs_with_sensor_data(self, info: Dict, apply_texture_transforms: bool = True) -> dict: + """Get the observation with sensor data""" + return dict( + agent=self._get_obs_agent(), + extra=self._get_obs_extra(info), + sensor_param=self.get_sensor_params(), + sensor_data=self._get_obs_sensor_data(apply_texture_transforms), + ) + + @property + def robot_link_names(self): + """Get link ids for the robot. This is used for segmentation observations.""" + return self.agent.robot_link_names + + # -------------------------------------------------------------------------- # + # Reward mode + # -------------------------------------------------------------------------- # + @property + def reward_mode(self): + return self._reward_mode + + def get_reward(self, obs: Any, action: torch.Tensor, info: Dict): + if self._reward_mode == "sparse": + reward = self.compute_sparse_reward(obs=obs, action=action, info=info) + elif self._reward_mode == "dense": + reward = self.compute_dense_reward(obs=obs, action=action, info=info) + elif self._reward_mode == "normalized_dense": + reward = self.compute_normalized_dense_reward( + obs=obs, action=action, info=info + ) + elif self._reward_mode == "none": + reward = torch.zeros((self.num_envs, ), dtype=torch.float, device=self.device) + else: + raise NotImplementedError(self._reward_mode) + return reward + + def compute_sparse_reward(self, obs: Any, action: torch.Tensor, info: Dict): + """ + Computes the sparse reward. By default this function tries to use the success/fail information in + returned by the evaluate function and gives +1 if success, -1 if fail, 0 otherwise""" + if "success" in info: + if "fail" in info: + if isinstance(info["success"], torch.Tensor): + reward = info["success"].to(torch.float) - info["fail"].to(torch.float) + else: + reward = info["success"] - info["fail"] + else: + reward = info["success"] + else: + if "fail" in info: + reward = -info["fail"] + else: + reward = torch.zeros(self.num_envs, dtype=torch.float, device=self.device) + return reward + + def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict): + raise NotImplementedError() + + def compute_normalized_dense_reward( + self, obs: Any, action: torch.Tensor, info: Dict + ): + raise NotImplementedError() + + # -------------------------------------------------------------------------- # + # Reconfigure + # -------------------------------------------------------------------------- # + def _reconfigure(self, options = dict()): + """Reconfigure the simulation scene instance. + This function clears the previous scene and creates a new one. + + Note this function is not always called when an environment is reset, and + should only be used if any agents, assets, sensors, lighting need to change + to save compute time. + + Tasks like PegInsertionSide and TurnFaucet will call this each time as the peg + shape changes each time and the faucet model changes each time respectively. + """ + + self._clear() + # load everything into the scene first before initializing anything + self._setup_scene() + + self._load_agent(options) + + self._load_scene(options) + self._load_lighting(options) + + self.scene._setup(enable_gpu=self.gpu_sim_enabled) + # for GPU sim, we have to setup sensors after we call setup gpu in order to enable loading mounted sensors as they depend on GPU buffer data + self._setup_sensors(options) + if self._viewer is not None: + self._setup_viewer() + self._reconfig_counter = self.reconfiguration_freq + + # delete various cached properties and reinitialize + # TODO (stao): The code is 3 lines because you have to initialize it once somewhere... + self.segmentation_id_map + del self.segmentation_id_map + self.segmentation_id_map + + def _after_reconfigure(self, options): + """Add code here that should run immediately after self._reconfigure is called. The torch RNG context is still active so RNG is still + seeded here by self._episode_seed. This is useful if you need to run something that only happens after reconfiguration but need the + GPU initialized so that you can check e.g. collisons, poses etc.""" + + def _load_scene(self, options: dict): + """Loads all objects like actors and articulations into the scene. Called by `self._reconfigure`. Given options argument + is the same options dictionary passed to the self.reset function""" + + # TODO (stao): refactor this into sensor API + def _setup_sensors(self, options: dict): + """Setup sensor configurations and the sensor objects in the scene. Called by `self._reconfigure`""" + + # First create all the configurations + self._sensor_configs = dict() + + # Add task/external sensors + self._sensor_configs.update(parse_camera_configs(self._default_sensor_configs)) + + # Add agent sensors + self._agent_sensor_configs = dict() + if self.agent is not None: + self._agent_sensor_configs = parse_camera_configs(self.agent._sensor_configs) + self._sensor_configs.update(self._agent_sensor_configs) + + # Add human render camera configs + self._human_render_camera_configs = parse_camera_configs( + self._default_human_render_camera_configs + ) + + self._viewer_camera_config = parse_camera_configs( + self._default_viewer_camera_configs + ) + + # Override camera configurations with user supplied configurations + if self._custom_sensor_configs is not None: + update_camera_configs_from_dict( + self._sensor_configs, self._custom_sensor_configs + ) + if self._custom_human_render_camera_configs is not None: + update_camera_configs_from_dict( + self._human_render_camera_configs, + self._custom_human_render_camera_configs, + ) + if self._custom_viewer_camera_configs is not None: + update_camera_configs_from_dict( + self._viewer_camera_config, + self._custom_viewer_camera_configs, + ) + self._viewer_camera_config = self._viewer_camera_config["viewer"] + + # Now we instantiate the actual sensor objects + self._sensors = dict() + + for uid, sensor_config in self._sensor_configs.items(): + if uid in self._agent_sensor_configs: + articulation = self.agent.robot + else: + articulation = None + if isinstance(sensor_config, StereoDepthCameraConfig): + sensor_cls = StereoDepthCamera + elif isinstance(sensor_config, CameraConfig): + sensor_cls = Camera + self._sensors[uid] = sensor_cls( + sensor_config, + self.scene, + articulation=articulation, + ) + + # Cameras for rendering only + self._human_render_cameras = dict() + for uid, camera_config in self._human_render_camera_configs.items(): + self._human_render_cameras[uid] = Camera( + camera_config, + self.scene, + ) + + self.scene.sensors = self._sensors + self.scene.human_render_cameras = self._human_render_cameras + + def _load_lighting(self, options: dict): + """Loads lighting into the scene. Called by `self._reconfigure`. If not overriden will set some simple default lighting""" + + shadow = self.enable_shadow + self.scene.set_ambient_light([0.3, 0.3, 0.3]) + self.scene.add_directional_light( + [1, 1, -1], [1, 1, 1], shadow=shadow, shadow_scale=5, shadow_map_size=2048 + ) + self.scene.add_directional_light([0, 0, -1], [1, 1, 1]) + # -------------------------------------------------------------------------- # + # Reset + # -------------------------------------------------------------------------- # + def reset(self, seed: Union[None, int, list[int]] = None, options: Union[None, dict] = None): + """Reset the ManiSkill environment with given seed(s) and options. Typically seed is either None (for unseeded reset) or an int (seeded reset). + For GPU parallelized environments you can also pass a list of seeds for each parallel environment to seed each one separately. + + If options["env_idx"] is given, will only reset the selected parallel environments. If + options["reconfigure"] is True, will call self._reconfigure() which deletes the entire physx scene and reconstructs everything. + Users building custom tasks generally do not need to override this function. + + Returns the first observation and a info dictionary. The info dictionary is of type + + + .. highlight:: python + .. code-block:: python + + { + "reconfigure": bool # (True if the env reconfigured. False otherwise) + } + + + + Note that ManiSkill always holds two RNG states, a main RNG, and an episode RNG. The main RNG is used purely to sample an episode seed which + helps with reproducibility of episodes and is for internal use only. The episode RNG is used by the environment/task itself to + e.g. randomize object positions, randomize assets etc. Episode RNG is accessible by using `self._batched_episode_rng` which is numpy based and `torch.rand` + which can be used to generate random data on the GPU directly and is seeded. Note that it is recommended to use `self._batched_episode_rng` + if you need to ensure during reconfiguration the same objects are loaded. Reproducibility and seeding when there is GPU and CPU simulation can be tricky and we recommend reading + the documentation for more recommendations and details on RNG https://maniskill.readthedocs.io/en/latest/user_guide/concepts/rng.html + + Upon environment creation via gym.make, the main RNG is set with fixed seeds of 2022 to 2022 + num_envs - 1 (seed is just 2022 if there is only one environment) + During each reset call, if seed is None, main RNG is unchanged and an episode seed is sampled from the main RNG to create the episode RNG. + If seed is not None, main RNG is set to that seed and the episode seed is also set to that seed. This design means the main RNG determines + the episode RNG deterministically. + + """ + if options is None: + options = dict() + reconfigure = options.get("reconfigure", False) + reconfigure = reconfigure or ( + self._reconfig_counter == 0 and self.reconfiguration_freq != 0 + ) + if "env_idx" in options: + env_idx = options["env_idx"] + if len(env_idx) != self.num_envs and reconfigure: + raise RuntimeError("Cannot do a partial reset and reconfigure the environment. You must do one or the other.") + else: + env_idx = torch.arange(0, self.num_envs, device=self.device) + + self._set_main_rng(seed) + + if reconfigure: + self._set_episode_rng(seed if seed is not None else self._batched_main_rng.randint(2**31), env_idx) + with torch.random.fork_rng(): + torch.manual_seed(seed=self._episode_seed[0]) + self._reconfigure(options) + self._after_reconfigure(options) + # Set the episode rng again after reconfiguration to guarantee seed reproducibility + self._set_episode_rng(self._episode_seed, env_idx) + else: + self._set_episode_rng(seed, env_idx) + + # TODO (stao): Reconfiguration when there is partial reset might not make sense and certainly broken here now. + # Solution to resolve that would be to ensure tasks that do reconfigure more than once are single-env only / cpu sim only + # or disable partial reset features explicitly for tasks that have a reconfiguration frequency + self.scene._reset_mask = torch.zeros( + self.num_envs, dtype=torch.bool, device=self.device + ) + self.scene._reset_mask[env_idx] = True + self._elapsed_steps[env_idx] = 0 + + self._clear_sim_state() + if self.reconfiguration_freq != 0: + self._reconfig_counter -= 1 + + if self.agent is not None: + self.agent.reset() + + if seed is not None or self._enhanced_determinism: + with torch.random.fork_rng(): + torch.manual_seed(self._episode_seed[0]) + self._initialize_episode(env_idx, options) + else: + self._initialize_episode(env_idx, options) + # reset the reset mask back to all ones so any internal code in maniskill can continue to manipulate all scenes at once as usual + self.scene._reset_mask = torch.ones( + self.num_envs, dtype=bool, device=self.device + ) + if self.gpu_sim_enabled: + # ensure all updates to object poses and configurations are applied on GPU after task initialization + self.scene._gpu_apply_all() + self.scene.px.gpu_update_articulation_kinematics() + self.scene._gpu_fetch_all() + + # we reset controllers here because some controllers depend on the agent/articulation qpos/poses + if self.agent is not None: + if isinstance(self.agent.controller, dict): + for controller in self.agent.controller.values(): + controller.reset() + else: + self.agent.controller.reset() + + info = self.get_info() + obs = self.get_obs(info) + + info["reconfigure"] = reconfigure + return obs, info + + def _set_main_rng(self, seed): + """Set the main random generator which is only used to set the seed of the episode RNG to improve reproducibility. + + Note that while _set_main_rng and _set_episode_rng are setting a seed and numpy random state, when using GPU sim + parallelization it is highly recommended to use torch random functions as they will make things run faster. The use + of torch random functions when building tasks in ManiSkill are automatically seeded via `torch.random.fork` + """ + if seed is None: + if self._main_seed is not None: + return + seed = np.random.RandomState().randint(2**31, size=(self.num_envs,)) + if not np.iterable(seed): + seed = [seed] + self._main_seed = seed + self._main_rng = np.random.RandomState(self._main_seed[0]) + if len(self._main_seed) == 1 and self.num_envs > 1: + self._main_seed = self._main_seed + np.random.RandomState(self._main_seed[0]).randint(2**31, size=(self.num_envs - 1,)).tolist() + self._batched_main_rng = BatchedRNG.from_seeds(self._main_seed, backend=self._batched_rng_backend) + + def _set_episode_rng(self, seed: Union[None, list[int]], env_idx: torch.Tensor): + """Set the random generator for current episode.""" + if seed is not None or self._enhanced_determinism: + env_idx = common.to_numpy(env_idx) + if seed is None: + self._episode_seed[env_idx] = self._batched_main_rng[env_idx].randint(2**31) + else: + if not np.iterable(seed): + seed = [seed] + self._episode_seed = common.to_numpy(seed, dtype=np.int64) + if len(self._episode_seed) == 1 and self.num_envs > 1: + self._episode_seed = np.concatenate((self._episode_seed, np.random.RandomState(self._episode_seed[0]).randint(2**31, size=(self.num_envs - 1,)))) + # we keep _episode_rng for backwards compatibility but recommend using _batched_episode_rng for randomization + if seed is not None or self._batched_episode_rng is None: + self._batched_episode_rng = BatchedRNG.from_seeds(self._episode_seed, backend=self._batched_rng_backend) + else: + self._batched_episode_rng[env_idx] = BatchedRNG.from_seeds(self._episode_seed[env_idx], backend=self._batched_rng_backend) + self._episode_rng = self._batched_episode_rng[0] + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + """Initialize the episode, e.g., poses of actors and articulations, as well as task relevant data like randomizing + goal positions + """ + + def _clear_sim_state(self): + """Clear simulation state (velocities)""" + for actor in self.scene.actors.values(): + if actor.px_body_type == "dynamic": + actor.set_linear_velocity(torch.zeros(3, device=self.device)) + actor.set_angular_velocity(torch.zeros(3, device=self.device)) + for articulation in self.scene.articulations.values(): + articulation.set_qvel(torch.zeros(articulation.max_dof, device=self.device)) + articulation.set_root_linear_velocity(torch.zeros(3, device=self.device)) + articulation.set_root_angular_velocity(torch.zeros(3, device=self.device)) + if self.gpu_sim_enabled: + self.scene._gpu_apply_all() + self.scene._gpu_fetch_all() + # TODO (stao): This may be an unnecessary fetch and apply. + + # -------------------------------------------------------------------------- # + # Step + # -------------------------------------------------------------------------- # + + def step(self, action: Union[None, np.ndarray, torch.Tensor, Dict]): + """ + Take a step through the environment with an action. Actions are automatically clipped to the action space. + + If ``action`` is None, the environment will proceed forward in time without sending any actions/control signals to the agent + """ + action = self._step_action(action) + self._elapsed_steps += 1 + info = self.get_info() + obs = self.get_obs(info) + reward = self.get_reward(obs=obs, action=action, info=info) + if "success" in info: + + if "fail" in info: + terminated = torch.logical_or(info["success"], info["fail"]) + else: + terminated = info["success"].clone() + else: + if "fail" in info: + terminated = info["fail"].clone() + else: + terminated = torch.zeros(self.num_envs, dtype=bool, device=self.device) + + return ( + obs, + reward, + terminated, + torch.zeros(self.num_envs, dtype=bool, device=self.device), + info, + ) + + def _step_action( + self, action: Union[None, np.ndarray, torch.Tensor, Dict] + ) -> Union[None, torch.Tensor]: + set_action = False + action_is_unbatched = False + if action is None: # simulation without action + pass + elif isinstance(action, np.ndarray) or isinstance(action, torch.Tensor): + action = common.to_tensor(action, device=self.device) + if action.shape == self._orig_single_action_space.shape: + action_is_unbatched = True + set_action = True + elif isinstance(action, dict): + if "control_mode" in action: + if action["control_mode"] != self.agent.control_mode: + self.agent.set_control_mode(action["control_mode"]) + self.agent.controller.reset() + action = common.to_tensor(action["action"], device=self.device) + if action.shape == self._orig_single_action_space.shape: + action_is_unbatched = True + else: + assert isinstance( + self.agent, MultiAgent + ), "Received a dictionary for an action but there are not multiple robots in the environment" + # assume this is a multi-agent action + action = common.to_tensor(action, device=self.device) + for k, a in action.items(): + if a.shape == self._orig_single_action_space[k].shape: + action_is_unbatched = True + break + set_action = True + else: + raise TypeError(type(action)) + + if set_action: + if self.num_envs == 1 and action_is_unbatched: + action = common.batch(action) + self.agent.set_action(action) + if self._sim_device.is_cuda(): + self.scene.px.gpu_apply_articulation_target_position() + self.scene.px.gpu_apply_articulation_target_velocity() + self._before_control_step() + for _ in range(self._sim_steps_per_control): + if self.agent is not None: + self.agent.before_simulation_step() + self._before_simulation_step() + self.scene.step() + self._after_simulation_step() + self._after_control_step() + if self.gpu_sim_enabled: + self.scene._gpu_fetch_all() + return action + + def evaluate(self) -> dict: + """ + Evaluate whether the environment is currently in a success state by returning a dictionary with a "success" key or + a failure state via a "fail" key + + This function may also return additional data that has been computed (e.g. is the robot grasping some object) that may be + reused when generating observations and rewards. + + By default if not overriden this function returns an empty dictionary + """ + return dict() + + def get_info(self) -> dict: + """ + Get info about the current environment state, include elapsed steps and evaluation information + """ + info = dict( + elapsed_steps=self.elapsed_steps + if not self.gpu_sim_enabled + else self._elapsed_steps.clone() + ) + info.update(self.evaluate()) + return info + + def _before_control_step(self): + """Code that runs before each action has been taken via env.step(action). + On GPU simulation this is called before observations are fetched from the GPU buffers.""" + def _after_control_step(self): + """Code that runs after each action has been taken. + On GPU simulation this is called right before observations are fetched from the GPU buffers.""" + + def _before_simulation_step(self): + """Code to run right before each physx_system.step is called""" + def _after_simulation_step(self): + """Code to run right after each physx_system.step is called""" + + # -------------------------------------------------------------------------- # + # Simulation and other gym interfaces + # -------------------------------------------------------------------------- # + def _set_scene_config(self): + physx.set_shape_config(contact_offset=self.sim_config.scene_config.contact_offset, rest_offset=self.sim_config.scene_config.rest_offset) + physx.set_body_config(solver_position_iterations=self.sim_config.scene_config.solver_position_iterations, solver_velocity_iterations=self.sim_config.scene_config.solver_velocity_iterations, sleep_threshold=self.sim_config.scene_config.sleep_threshold) + physx.set_scene_config(gravity=self.sim_config.scene_config.gravity, bounce_threshold=self.sim_config.scene_config.bounce_threshold, enable_pcm=self.sim_config.scene_config.enable_pcm, enable_tgs=self.sim_config.scene_config.enable_tgs, enable_ccd=self.sim_config.scene_config.enable_ccd, enable_enhanced_determinism=self.sim_config.scene_config.enable_enhanced_determinism, enable_friction_every_iteration=self.sim_config.scene_config.enable_friction_every_iteration, cpu_workers=self.sim_config.scene_config.cpu_workers ) + physx.set_default_material(**self.sim_config.default_materials_config.dict()) + + def _setup_scene(self): + """Setup the simulation scene instance. + The function should be called in reset(). Called by `self._reconfigure`""" + self._set_scene_config() + if self._sim_device.is_cuda(): + physx_system = physx.PhysxGpuSystem(device=self._sim_device) + # Create the scenes in a square grid + sub_scenes = [] + scene_grid_length = int(np.ceil(np.sqrt(self.num_envs))) + for scene_idx in range(self.num_envs): + scene_x, scene_y = ( + scene_idx % scene_grid_length - scene_grid_length // 2, + scene_idx // scene_grid_length - scene_grid_length // 2, + ) + scene = sapien.Scene( + systems=[physx_system, sapien.render.RenderSystem(self._render_device)] + ) + physx_system.set_scene_offset( + scene, + [ + scene_x * self.sim_config.spacing, + scene_y * self.sim_config.spacing, + 0, + ], + ) + sub_scenes.append(scene) + else: + physx_system = physx.PhysxCpuSystem() + sub_scenes = [ + sapien.Scene([physx_system, sapien.render.RenderSystem(self._render_device)]) + ] + # create a "global" scene object that users can work with that is linked with all other scenes created + self.scene = ManiSkillScene( + sub_scenes, + sim_config=self.sim_config, + device=self.device, + parallel_in_single_scene=self._parallel_in_single_scene, + backend=self.backend + ) + self.scene.px.timestep = 1.0 / self._sim_freq + + def _clear(self): + """Clear the simulation scene instance and other buffers. + The function can be called in reset() before a new scene is created. + Called by `self._reconfigure` and when the environment is closed/deleted + """ + self._close_viewer() + self.agent = None + self._sensors = dict() + self._human_render_cameras = dict() + self.scene = None + self._hidden_objects = [] + gc.collect() # force gc to collect which releases most GPU memory + + def close(self): + self._clear() + + def _close_viewer(self): + if self._viewer is None: + return + self._viewer.close() + self._viewer = None + + @cached_property + def segmentation_id_map(self): + """ + Returns a dictionary mapping every ID to the appropriate Actor or Link object + """ + res = dict() + for actor in self.scene.actors.values(): + res[actor._objs[0].per_scene_id] = actor + for art in self.scene.articulations.values(): + for link in art.links: + res[link._objs[0].entity.per_scene_id] = link + return res + + def add_to_state_dict_registry(self, object: Union[Actor, Articulation]): + self.scene.add_to_state_dict_registry(object) + def remove_from_state_dict_registry(self, object: Union[Actor, Articulation]): + self.scene.remove_from_state_dict_registry(object) + + def get_state_dict(self): + """ + Get environment state dictionary. Override to include task information (e.g., goal) + """ + return self.scene.get_sim_state() + + def get_state(self): + """ + Get environment state as a flat vector, which is just a ordered flattened version of the state_dict. + + Users should not override this function + """ + return common.flatten_state_dict(self.get_state_dict(), use_torch=True) + + def set_state_dict(self, state: Dict, env_idx: torch.Tensor = None): + """ + Set environment state with a state dictionary. Override to include task information (e.g., goal) + + Note that it is recommended to keep around state dictionaries as opposed to state vectors. With state vectors we assume + the order of data in the vector is the same exact order that would be returned by flattening the state dictionary you get from + `env.get_state_dict()` or the result of `env.get_state()` + """ + self.scene.set_sim_state(state, env_idx) + if self.gpu_sim_enabled: + self.scene._gpu_apply_all() + self.scene.px.gpu_update_articulation_kinematics() + self.scene._gpu_fetch_all() + + def set_state(self, state: Array, env_idx: torch.Tensor = None): + """ + Set environment state with a flat state vector. Internally this reconstructs the state dictionary and calls `env.set_state_dict` + + Users should not override this function + """ + state_dict = dict() + state_dict["actors"] = dict() + state_dict["articulations"] = dict() + KINEMATIC_DIM = 13 # [pos, quat, lin_vel, ang_vel] + start = 0 + for actor_id in self._init_raw_state["actors"].keys(): + state_dict["actors"][actor_id] = state[:, start : start + KINEMATIC_DIM] + start += KINEMATIC_DIM + for art_id, art_state in self._init_raw_state["articulations"].items(): + size = art_state.shape[-1] + state_dict["articulations"][art_id] = state[:, start : start + size] + start += size + self.set_state_dict(state_dict, env_idx) + + # -------------------------------------------------------------------------- # + # Visualization + # -------------------------------------------------------------------------- # + @property + def viewer(self): + return self._viewer + + def _setup_viewer(self): + """Setup the interactive viewer. + + The function should be called after a new scene is configured. + In subclasses, this function can be overridden to set viewer cameras. + + Called by `self._reconfigure` + """ + self._viewer.set_scene(self.scene.sub_scenes[0]) + control_window: sapien.utils.viewer.control_window.ControlWindow = ( + sapien_utils.get_obj_by_type( + self._viewer.plugins, sapien.utils.viewer.control_window.ControlWindow + ) + ) + control_window.show_joint_axes = False + control_window.show_camera_linesets = False + if "render_camera" in self._human_render_cameras: + self._viewer.set_camera_pose( + self._human_render_cameras["render_camera"].camera.global_pose[0].sp + ) + + def render_human(self): + """render the environment by opening a GUI viewer. This also returns the viewer object. Any objects registered in the _hidden_objects list will be shown""" + for obj in self._hidden_objects: + obj.show_visual() + if self._viewer is None: + self._viewer = create_viewer(self._viewer_camera_config) + self._setup_viewer() + if self.gpu_sim_enabled and self.scene._gpu_sim_initialized: + self.scene.px.sync_poses_gpu_to_cpu() + self._viewer.render() + for obj in self._hidden_objects: + obj.hide_visual() + return self._viewer + + def render_rgb_array(self, camera_name: str = None): + """Returns an RGB array / image of size (num_envs, H, W, 3) of the current state of the environment. + This is captured by any of the registered human render cameras. If a camera_name is given, only data from that camera is returned. + Otherwise all camera data is captured and returned as a single batched image. Any objects registered in the _hidden_objects list will be shown""" + for obj in self._hidden_objects: + obj.show_visual() + self.scene.update_render(update_sensors=False, update_human_render_cameras=True) + images = [] + render_images = self.scene.get_human_render_camera_images(camera_name) + for image in render_images.values(): + images.append(image) + if len(images) == 0: + return None + if len(images) == 1: + return images[0] + for obj in self._hidden_objects: + obj.hide_visual() + return tile_images(images) + + def render_sensors(self): + """ + Renders all sensors that the agent can use and see and displays them in a human readable image format. + Any objects registered in the _hidden_objects list will not be shown + """ + images = [] + sensor_images = self.get_sensor_images() + for image in sensor_images.values(): + for img in image.values(): + images.append(img) + return tile_images(images) + + def render_all(self): + """Renders all human render cameras and sensors together""" + images = [] + for obj in self._hidden_objects: + obj.show_visual() + self.scene.update_render(update_sensors=True, update_human_render_cameras=True) + render_images = self.scene.get_human_render_camera_images() + # note that get_sensor_images function will update the render and hide objects itself + sensor_images = self.get_sensor_images() + for image in render_images.values(): + images.append(image) + for image in sensor_images.values(): + for img in image.values(): + images.append(img) + return tile_images(images) + + def render(self): + """ + Either opens a viewer if ``self.render_mode`` is "human", or returns an array that you can use to save videos. + + If ``self.render_mode`` is "rgb_array", usually a higher quality image is rendered for the purpose of viewing only. + + If ``self.render_mode`` is "sensors", all visual observations the agent can see is provided + + If ``self.render_mode`` is "all", this is then a combination of "rgb_array" and "sensors" + """ + if self.render_mode is None: + raise RuntimeError("render_mode is not set.") + if self.render_mode == "human": + return self.render_human() + elif self.render_mode == "rgb_array": + res = self.render_rgb_array() + return res + elif self.render_mode == "sensors": + res = self.render_sensors() + return res + elif self.render_mode == "all": + return self.render_all() + else: + raise NotImplementedError(f"Unsupported render mode {self.render_mode}.") + + # TODO (stao): re implement later + # ---------------------------------------------------------------------------- # + # Advanced + # ---------------------------------------------------------------------------- # + + # def gen_scene_pcd(self, num_points: int = int(1e5)) -> np.ndarray: + # """Generate scene point cloud for motion planning, excluding the robot""" + # meshes = [] + # articulations = self.scene.get_all_articulations() + # if self.agent is not None: + # articulations.pop(articulations.index(self.agent.robot)) + # for articulation in articulations: + # articulation_mesh = merge_meshes(get_articulation_meshes(articulation)) + # if articulation_mesh: + # meshes.append(articulation_mesh) + + # for actor in self.scene.get_all_actors(): + # actor_mesh = merge_meshes(get_component_meshes(actor)) + # if actor_mesh: + # meshes.append( + # actor_mesh.apply_transform( + # actor.get_pose().to_transformation_matrix() + # ) + # ) + + # scene_mesh = merge_meshes(meshes) + # scene_pcd = scene_mesh.sample(num_points) + # return scene_pcd + + + # Printing metrics/info + def print_sim_details(self): + """Debug tool to call to simply print a bunch of details about the running environment, including the task ID, number of environments, sim backend, etc.""" + sensor_settings_str = [] + for uid, cam in self._sensors.items(): + if isinstance(cam, Camera): + config = cam.config + sensor_settings_str.append(f"RGBD({config.width}x{config.height})") + sensor_settings_str = ", ".join(sensor_settings_str) + sim_backend = self.backend.sim_backend + print( + "# -------------------------------------------------------------------------- #" + ) + print( + f"Task ID: {self.spec.id}, {self.num_envs} parallel environments, sim_backend={sim_backend}" + ) + print( + f"obs_mode={self.obs_mode}, control_mode={self.control_mode}" + ) + print( + f"render_mode={self.render_mode}, sensor_details={sensor_settings_str}" + ) + print( + f"sim_freq={self.sim_freq}, control_freq={self.control_freq}" + ) + print(f"observation space: {self.observation_space}") + print(f"(single) action space: {self.single_action_space}") + print( + "# -------------------------------------------------------------------------- #" + ) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/scene.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/scene.py new file mode 100644 index 0000000000000000000000000000000000000000..cfcf835e3c7a897e516cba9432aecffd2766d56f --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/scene.py @@ -0,0 +1,1163 @@ +from dataclasses import dataclass +from functools import cached_property +from typing import Any, Dict, List, Optional, Tuple, Union + +import numpy as np +import sapien +import sapien.physx as physx +import sapien.render +import torch +from sapien.render import RenderCameraComponent + +from mani_skill.envs.utils.system.backend import BackendInfo +from mani_skill.render import SAPIEN_RENDER_SYSTEM +from mani_skill.sensors.base_sensor import BaseSensor +from mani_skill.sensors.camera import Camera +from mani_skill.utils import common, sapien_utils +from mani_skill.utils.structs.actor import Actor +from mani_skill.utils.structs.articulation import Articulation +from mani_skill.utils.structs.drive import Drive +from mani_skill.utils.structs.link import Link +from mani_skill.utils.structs.pose import Pose +from mani_skill.utils.structs.render_camera import RenderCamera +from mani_skill.utils.structs.types import Array, Device, SimConfig + +# try and determine which render system is used by the installed sapien package +if SAPIEN_RENDER_SYSTEM == "3.1": + from sapien.wrapper.scene import get_camera_shader_pack + + GlobalShaderPack = None + sapien.render.RenderCameraGroup = "oldtype" # type: ignore + + +@dataclass +class StateDictRegistry: + actors: Dict[str, Actor] + articulations: Dict[str, Articulation] + + +class ManiSkillScene: + """ + Class that manages a list of sub-scenes (sapien.Scene). In CPU simulation there should only be one sub-scene. + In GPU simulation, there can be many sub-scenes, and this wrapper ensures that use calls to many of the original sapien.Scene API + are applied to all sub-scenes. This includes calls to change object poses, velocities, drive targets etc. + + This wrapper also helps manage GPU states if GPU simulation is used + """ + + def __init__( + self, + sub_scenes: Optional[List[sapien.Scene]] = None, + sim_config: SimConfig = SimConfig(), + debug_mode: bool = True, + device: Device = None, + parallel_in_single_scene: bool = False, + backend: BackendInfo = None, + ): + if sub_scenes is None: + sub_scenes = [sapien.Scene()] + self.sub_scenes = sub_scenes + self.px: Union[physx.PhysxCpuSystem, physx.PhysxGpuSystem] = self.sub_scenes[ + 0 + ].physx_system + assert all( + isinstance(s.physx_system, type(self.px)) for s in self.sub_scenes + ), "all sub-scenes must use the same simulation backend" + self.gpu_sim_enabled = ( + True if isinstance(self.px, physx.PhysxGpuSystem) else False + ) + """whether the sub scenes are using the GPU or CPU backend""" + self.sim_config = sim_config + self._gpu_sim_initialized = False + self.debug_mode = debug_mode + self.device = device + self.backend = backend # references the backend object stored in BaseEnv class + + self.render_system_group: sapien.render.RenderSystemGroup = None + self.camera_groups: Dict[str, sapien.render.RenderCameraGroup] = dict() + + self.actors: Dict[str, Actor] = dict() + self.articulations: Dict[str, Articulation] = dict() + + self.actor_views: Dict[str, Actor] = dict() + """views of actors in any sub-scenes created by using Actor.merge and queryable as if it were a single Actor""" + self.articulation_views: Dict[str, Articulation] = dict() + """views of articulations in any sub-scenes created by using Articulation.merge and queryable as if it were a single Articulation""" + + self.sensors: Dict[str, BaseSensor] = dict() + self.human_render_cameras: Dict[str, Camera] = dict() + self._sensors_initialized = False + self._human_render_cameras_initialized = False + + self._reset_mask = torch.ones(len(sub_scenes), dtype=bool, device=self.device) + """Used internally by various objects like Actor, Link, and Controllers to auto mask out sub-scenes so they do not get modified during + partial env resets""" + + self._needs_fetch = False + """Used internally to raise some errors ahead of time of when there may be undefined behaviors""" + + self.pairwise_contact_queries: Dict[ + str, physx.PhysxGpuContactPairImpulseQuery + ] = dict() + """dictionary mapping pairwise contact query keys to GPU contact queries. Used in GPU simulation only to cache queries as + query creation will pause any GPU sim computation""" + self._pairwise_contact_query_unique_hashes: Dict[str, int] = dict() + """maps keys in self.pairwise_contact_queries to unique hashes dependent on the actual objects involved in the query. + This is used to determine automatically when to rebuild contact queries as keys for self.pairwise_contact_queries are kept + non-unique between episode resets in order to be easily rebuilt and deallocate old queries. This essentially acts as a way + to invalidate the cached queries.""" + + self.parallel_in_single_scene: bool = parallel_in_single_scene + """Whether rendering all parallel scenes in the viewer/gui is enabled""" + + self.state_dict_registry: StateDictRegistry = StateDictRegistry( + actors=dict(), articulations=dict() + ) + """state dict registry that map actor/articulation names to Actor/Articulation struct references. Only these structs are used for the environment state""" + + # -------------------------------------------------------------------------- # + # Functions from sapien.Scene + # -------------------------------------------------------------------------- # + @property + def timestep(self): + """The current simulation timestep""" + return self.px.timestep + + @timestep.setter + def timestep(self, timestep): + self.px.timestep = timestep + + def set_timestep(self, timestep): + """Sets the current simulation timestep""" + self.timestep = timestep + + def get_timestep(self): + """Returns the current simulation timestep""" + return self.timestep + + def create_actor_builder(self): + """Creates an ActorBuilder object that can be used to build actors in this scene""" + from ..utils.building.actor_builder import ActorBuilder + + return ActorBuilder().set_scene(self) + + def create_articulation_builder(self): + """Creates an ArticulationBuilder object that can be used to build articulations in this scene""" + from ..utils.building.articulation_builder import ArticulationBuilder + + return ArticulationBuilder().set_scene(self) + + def create_urdf_loader(self): + """Creates a URDFLoader object that can be used to load URDF files into this scene""" + from ..utils.building.urdf_loader import URDFLoader + + loader = URDFLoader() + loader.set_scene(self) + return loader + + def create_mjcf_loader(self): + """Creates a MJCFLoader object that can be used to load MJCF files into this scene""" + from ..utils.building.mjcf_loader import MJCFLoader + + loader = MJCFLoader() + loader.set_scene(self) + return loader + + # def create_physical_material( + # self, static_friction: float, dynamic_friction: float, restitution: float + # ): + # return physx.PhysxMaterial(static_friction, dynamic_friction, restitution) + + def remove_actor(self, actor: Actor): + """Removes an actor from the scene. Only works in CPU simulation.""" + if self.gpu_sim_enabled: + raise NotImplementedError( + "Cannot remove actors after creating them in GPU sim at the moment" + ) + else: + self.sub_scenes[0].remove_entity(actor._objs[0].entity) + self.actors.pop(actor.name) + + def remove_articulation(self, articulation: Articulation): + """Removes an articulation from the scene. Only works in CPU simulation.""" + if self.gpu_sim_enabled: + raise NotImplementedError( + "Cannot remove articulations after creating them in GPU sim at the moment" + ) + else: + entities = [l.entity for l in articulation._objs[0].links] + for e in entities: + self.sub_scenes[0].remove_entity(e) + self.articulations.pop(articulation.name) + + def add_camera( + self, + name, + pose, + width, + height, + near, + far, + fovy: Union[float, List, None] = None, + intrinsic: Union[Array, None] = None, + mount: Union[Actor, Link, None] = None, + ) -> RenderCamera: + """Add's a (mounted) camera to the scene""" + if SAPIEN_RENDER_SYSTEM == "3.1": + return self._sapien_31_add_camera( + name, pose, width, height, near, far, fovy, intrinsic, mount + ) + else: + return self._sapien_add_camera( + name, pose, width, height, near, far, fovy, intrinsic, mount + ) + + def _sapien_add_camera( + self, + name, + pose, + width, + height, + near, + far, + fovy: Union[float, List, None] = None, + intrinsic: Union[Array, None] = None, + mount: Union[Actor, Link, None] = None, + ) -> RenderCamera: + """internal helper function to add (mounted) cameras""" + cameras = [] + pose = Pose.create(pose) + # TODO (stao): support scene idxs property for cameras in the future + # move intrinsic to np and batch intrinsic if it is not batched + if intrinsic is not None: + intrinsic = common.to_numpy(intrinsic) + if len(intrinsic.shape) == 2: + intrinsic = intrinsic[None, :] + if len(self.sub_scenes) > 1: + # repeat the intrinsic along batch dim + intrinsic = intrinsic.repeat(len(self.sub_scenes), 0) + assert len(intrinsic) == len( + self.sub_scenes + ), "intrinsic matrix batch dim not equal to the number of sub-scenes" + for i, scene in enumerate(self.sub_scenes): + # Create camera component + camera = RenderCameraComponent(width, height) + if fovy is not None: + if isinstance(fovy, float) or isinstance(fovy, int): + camera.set_fovy(fovy, compute_x=True) + else: + camera.set_fovy(fovy[i], compute_x=True) + elif intrinsic is not None: + camera.set_focal_lengths(intrinsic[i, 0, 0], intrinsic[i, 1, 1]) + camera.set_principal_point(intrinsic[i, 0, 2], intrinsic[i, 1, 2]) + if isinstance(near, float) or isinstance(near, int): + camera.near = near + else: + camera.near = near[i] + if isinstance(far, float) or isinstance(far, int): + camera.far = far + else: + camera.far = far[i] + + # mount camera to actor/link + if mount is not None: + if self.gpu_sim_enabled: + if isinstance(mount, Actor): + camera.set_gpu_pose_batch_index( + mount._objs[i] + .find_component_by_type(physx.PhysxRigidBodyComponent) + .gpu_pose_index + ) + elif isinstance(mount, Link): + camera.set_gpu_pose_batch_index(mount._objs[i].gpu_pose_index) + else: + raise ValueError( + f"Tried to mount camera on object of type {mount.__class__}" + ) + if isinstance(mount, Link): + mount._objs[i].entity.add_component(camera) + else: + mount._objs[i].add_component(camera) + else: + camera_mount = sapien.Entity() + camera_mount.add_component(camera) + scene.add_entity(camera_mount) + camera_mount.name = f"scene-{i}_{name}" + if len(pose) == 1: + camera.local_pose = pose.sp + else: + camera.local_pose = pose[i].sp + camera.name = f"scene-{i}_{name}" + cameras.append(camera) + return RenderCamera.create(cameras, self, mount=mount) + + def _sapien_31_add_camera( + self, + name, + pose, + width, + height, + near, + far, + fovy: Union[float, List, None] = None, + intrinsic: Union[Array, None] = None, + mount: Union[Actor, Link, None] = None, + ) -> RenderCamera: + """internal helper function to add (mounted) cameras""" + cameras = [] + pose = Pose.create(pose) + # TODO (stao): support scene idxs property for cameras in the future + # move intrinsic to np and batch intrinsic if it is not batched + if intrinsic is not None: + intrinsic = common.to_numpy(intrinsic) + if len(intrinsic.shape) == 2: + intrinsic = intrinsic[None, :] + if len(self.sub_scenes) > 1: + # repeat the intrinsic along batch dim + intrinsic = intrinsic.repeat(len(self.sub_scenes), 0) + assert len(intrinsic) == len( + self.sub_scenes + ), "intrinsic matrix batch dim not equal to the number of sub-scenes" + + for i, scene in enumerate(self.sub_scenes): + # Create camera component + camera = RenderCameraComponent( + width, height, GlobalShaderPack or get_camera_shader_pack() + ) + if fovy is not None: + if isinstance(fovy, (float, int)): + camera.set_fovy(fovy, compute_x=True) + else: + camera.set_fovy(fovy[i], compute_x=True) + elif intrinsic is not None: + camera.set_focal_lengths(intrinsic[i, 0, 0], intrinsic[i, 1, 1]) + camera.set_principal_point(intrinsic[i, 0, 2], intrinsic[i, 1, 2]) + if isinstance(near, (float, int)): + camera.near = near + else: + camera.near = near[i] + if isinstance(far, (float, int)): + camera.far = far + else: + camera.far = far[i] + + # mount camera to actor/link + if mount is not None: + if isinstance(mount, Link): + mount._objs[i].entity.add_component(camera) + else: + mount._objs[i].add_component(camera) + else: + camera_mount = sapien.Entity() + camera_mount.set_pose(sapien.Pose([0, 0, 0])) + camera_mount.add_component(camera) + camera_mount.name = f"scene-{i}_{name}" + scene.add_entity(camera_mount) + if len(pose) == 1: + camera.local_pose = pose.sp + else: + camera.local_pose = pose[i].sp + camera.name = f"scene-{i}_{name}" + cameras.append(camera) + scene.update_render() + return RenderCamera.create(cameras, self, mount=mount) + + # def remove_camera(self, camera): + # self.remove_entity(camera.entity) + + # def get_cameras(self): + # return self.render_system.cameras + + # def get_mounted_cameras(self): + # return self.get_cameras() + + def step(self): + self.px.step() + + def update_render( + self, update_sensors: bool = True, update_human_render_cameras: bool = True + ): + """ + Updates the renderer based on the current simulation state. Note that on the first call if a sensor/human render camera is required to be updated, + GPU memory will be allocated for the sensor/human render camera respectively. + + Arguments: + update_sensors (bool): Whether to update the sensors. + update_human_render_cameras (bool): Whether to update the human render cameras. + """ + if SAPIEN_RENDER_SYSTEM == "3.1": + self._sapien_31_update_render( + update_sensors=update_sensors, + update_human_render_cameras=update_human_render_cameras, + ) + else: + self._sapien_update_render( + update_sensors=update_sensors, + update_human_render_cameras=update_human_render_cameras, + ) + + def _sapien_update_render( + self, update_sensors: bool = True, update_human_render_cameras: bool = True + ): + # note that this design is such that no GPU memory is allocated for memory unless requested for, which can occur + # after the e.g. physx GPU simulation is initialized. + if self.gpu_sim_enabled: + if not self.parallel_in_single_scene: + if self.render_system_group is None: + self._setup_gpu_rendering() + if not self._sensors_initialized and update_sensors: + self._gpu_setup_sensors(self.sensors) + self._sensors_initialized = True + if ( + not self._human_render_cameras_initialized + and update_human_render_cameras + ): + self._gpu_setup_sensors(self.human_render_cameras) + self._human_render_cameras_initialized = True + self.render_system_group.update_render() + else: + self.px.sync_poses_gpu_to_cpu() + self.sub_scenes[0].update_render() + else: + self.sub_scenes[0].update_render() + + def _sapien_31_update_render( + self, update_sensors: bool = True, update_human_render_cameras: bool = True + ): + if self.gpu_sim_enabled: + if self.render_system_group is None: + # TODO (stao): for new render system support the parallel in single scene rendering option + for scene in self.sub_scenes: + scene.update_render() + self._setup_gpu_rendering() + if not self._sensors_initialized and update_sensors: + self._gpu_setup_sensors(self.sensors) + self._sensors_initialized = True + if ( + not self._human_render_cameras_initialized + and update_human_render_cameras + ): + self._gpu_setup_sensors(self.human_render_cameras) + self._human_render_cameras_initialized = True + + manager: sapien.render.GpuSyncManager = self.render_system_group + manager.sync() + else: + self.sub_scenes[0].update_render() + + def get_contacts(self): + # TODO (stao): deprecate this API + return self.px.get_contacts() + + def get_all_actors(self): + """ + Returns list of all sapien.Entity objects that have rigid dynamic and static components across all sub scenes + """ + return [ + c.entity + for c in self.px.rigid_dynamic_components + self.px.rigid_static_components + ] + + def get_all_articulations(self): + """ + Returns list of all physx articulation objects across all sub scenes + """ + return [ + c.articulation for c in self.px.articulation_link_components if c.is_root + ] + + def create_drive( + self, + body0: Union[Actor, Link], + pose0: Union[sapien.Pose, Pose], + body1: Union[Actor, Link], + pose1: Union[sapien.Pose, Pose], + ): + # body0 and body1 should be in parallel. + return Drive.create_from_actors_or_links( + self, body0, pose0, body1, pose1, body0._scene_idxs + ) + + # def create_connection( + # self, + # body0: Optional[Union[sapien.Entity, physx.PhysxRigidBaseComponent]], + # pose0: sapien.Pose, + # body1: Union[sapien.Entity, physx.PhysxRigidBaseComponent], + # pose1: sapien.Pose, + # ): + # if body0 is None: + # c0 = None + # elif isinstance(body0, sapien.Entity): + # c0 = next( + # c + # for c in body0.components + # if isinstance(c, physx.PhysxRigidBaseComponent) + # ) + # else: + # c0 = body0 + + # assert body1 is not None + # if isinstance(body1, sapien.Entity): + # e1 = body1 + # c1 = next( + # c + # for c in body1.components + # if isinstance(c, physx.PhysxRigidBaseComponent) + # ) + # else: + # e1 = body1.entity + # c1 = body1 + + # connection = physx.PhysxDistanceJointComponent(c1) + # connection.parent = c0 + # connection.pose_in_child = pose1 + # connection.pose_in_parent = pose0 + # e1.add_component(connection) + # connection.set_limit(0, 0) + # return connection + + # def create_gear( + # self, + # body0: Optional[Union[sapien.Entity, physx.PhysxRigidBaseComponent]], + # pose0: sapien.Pose, + # body1: Union[sapien.Entity, physx.PhysxRigidBaseComponent], + # pose1: sapien.Pose, + # ): + # if body0 is None: + # c0 = None + # elif isinstance(body0, sapien.Entity): + # c0 = next( + # c + # for c in body0.components + # if isinstance(c, physx.PhysxRigidBaseComponent) + # ) + # else: + # c0 = body0 + + # assert body1 is not None + # if isinstance(body1, sapien.Entity): + # e1 = body1 + # c1 = next( + # c + # for c in body1.components + # if isinstance(c, physx.PhysxRigidBaseComponent) + # ) + # else: + # e1 = body1.entity + # c1 = body1 + + # gear = physx.PhysxGearComponent(c1) + # gear.parent = c0 + # gear.pose_in_child = pose1 + # gear.pose_in_parent = pose0 + # e1.add_component(gear) + # return gear + + # @property + # def render_id_to_visual_name(self): + # # TODO + # return + + @property + def ambient_light(self): + return self.sub_scenes[0].ambient_light + + @ambient_light.setter + def ambient_light(self, color): + for scene in self.sub_scenes: + scene.render_system.ambient_light = color + + def set_ambient_light(self, color): + self.ambient_light = color + + def add_point_light( + self, + position, + color, + shadow=False, + shadow_near=0.1, + shadow_far=10.0, + shadow_map_size=2048, + scene_idxs: Optional[List[int]] = None, + ): + if scene_idxs is None: + scene_idxs = list(range(len(self.sub_scenes))) + for scene_idx in scene_idxs: + if self.parallel_in_single_scene: + scene = self.sub_scenes[0] + else: + scene = self.sub_scenes[scene_idx] + entity = sapien.Entity() + entity.name = "point_light" + light = sapien.render.RenderPointLightComponent() + entity.add_component(light) + light.color = color + light.shadow = shadow + light.shadow_near = shadow_near + light.shadow_far = shadow_far + light.shadow_map_size = shadow_map_size + if self.parallel_in_single_scene: + light.pose = sapien.Pose(position + self.scene_offsets_np[scene_idx]) + else: + light.pose = sapien.Pose(position) + + scene.add_entity(entity) + return light + + def add_directional_light( + self, + direction, + color, + shadow=False, + position=[0, 0, 0], + shadow_scale=10.0, + shadow_near=-10.0, + shadow_far=10.0, + shadow_map_size=2048, + scene_idxs: Optional[List[int]] = None, + ): + if scene_idxs is None: + scene_idxs = list(range(len(self.sub_scenes))) + for scene_idx in scene_idxs: + if self.parallel_in_single_scene: + scene = self.sub_scenes[0] + else: + scene = self.sub_scenes[scene_idx] + entity = sapien.Entity() + entity.name = "directional_light" + light = sapien.render.RenderDirectionalLightComponent() + entity.add_component(light) + light.color = color + light.shadow = shadow + light.shadow_near = shadow_near + light.shadow_far = shadow_far + light.shadow_half_size = shadow_scale + light.shadow_map_size = shadow_map_size + if self.parallel_in_single_scene: + light_position = position + self.scene_offsets_np[scene_idx] + else: + light_position = position + light.pose = sapien.Pose( + light_position, sapien.math.shortest_rotation([1, 0, 0], direction) + ) + scene.add_entity(entity) + if self.parallel_in_single_scene: + # for directional lights adding multiple does not make much sense + # and for parallel gui rendering setup accurate lighting does not matter as it is only + # for demo purposes + break + return + + def add_spot_light( + self, + position, + direction, + inner_fov: float, + outer_fov: float, + color, + shadow=False, + shadow_near=0.1, + shadow_far=10.0, + shadow_map_size=2048, + scene_idxs: Optional[List[int]] = None, + ): + if scene_idxs is None: + scene_idxs = list(range(len(self.sub_scenes))) + for scene_idx in scene_idxs: + if self.parallel_in_single_scene: + scene = self.sub_scenes[0] + else: + scene = self.sub_scenes[scene_idx] + entity = sapien.Entity() + entity.name = "spot_light" + light = sapien.render.RenderSpotLightComponent() + entity.add_component(light) + light.color = color + light.shadow = shadow + light.shadow_near = shadow_near + light.shadow_far = shadow_far + light.shadow_map_size = shadow_map_size + light.inner_fov = inner_fov + light.outer_fov = outer_fov + if self.parallel_in_single_scene: + light_position = position + self.scene_offsets_np[scene_idx] + else: + light_position = position + light.pose = sapien.Pose( + light_position, sapien.math.shortest_rotation([1, 0, 0], direction) + ) + scene.add_entity(entity) + return + + def add_area_light_for_ray_tracing( + self, + pose: sapien.Pose, + color, + half_width: float, + half_height: float, + scene_idxs=None, + ): + lighting_scenes = ( + self.sub_scenes + if scene_idxs is None + else [self.sub_scenes[i] for i in scene_idxs] + ) + for scene in lighting_scenes: + entity = sapien.Entity() + light = sapien.render.RenderParallelogramLightComponent() + entity.add_component(light) + light.set_shape(half_width, half_height) + light.color = color + light.pose = pose + scene.add_entity(entity) + return + + # def remove_light(self, light): + # self.remove_entity(light.entity) + + # def set_environment_map(self, cubemap: str): + # if isinstance(cubemap, str): + # self.render_system.cubemap = sapien.render.RenderCubemap(cubemap) + # else: + # self.render_system.cubemap = cubemap + + # def set_environment_map_from_files( + # self, px: str, nx: str, py: str, ny: str, pz: str, nz: str + # ): + # self.render_system.cubemap = sapien.render.RenderCubemap(px, nx, py, ny, pz, nz) + + # ---------------------------------------------------------------------------- # + # Additional useful properties / functions + # ---------------------------------------------------------------------------- # + @property + def num_envs(self): + return len(self.sub_scenes) + + def get_pairwise_contact_impulses( + self, obj1: Union[Actor, Link], obj2: Union[Actor, Link] + ): + """ + Get the impulse vectors between two actors/links. Returns impulse vector of shape (N, 3) + where N is the number of environments and 3 is the dimension of the impulse vector itself, + representing x, y, and z direction of impulse. + + Note that dividing the impulse value by self.px.timestep yields the pairwise contact force in Newtons. The equivalent API for that + is self.get_pairwise_contact_force(obj1, obj2). It is generally recommended to use the force values since they are independent of the + timestep (dt = 1 / sim_freq) of the simulation. + + Args: + obj1: Actor | Link + obj2: Actor | Link + """ + # TODO (stao): Is there any optimization improvement when putting all queries all together and fetched together + # vs multiple smaller queries? If so, might be worth exposing a helpful API for that instead of having user + # write this code below themselves. + if self.gpu_sim_enabled: + query_hash = hash((obj1, obj2)) + query_key = obj1.name + obj2.name + + # we rebuild the potentially expensive contact query if it has not existed previously + # or if it has, the managed objects are a different set + rebuild_query = (query_key not in self.pairwise_contact_queries) or ( + query_key in self._pairwise_contact_query_unique_hashes + and self._pairwise_contact_query_unique_hashes[query_key] != query_hash + ) + if rebuild_query: + body_pairs = list(zip(obj1._bodies, obj2._bodies)) + self.pairwise_contact_queries[ + query_key + ] = self.px.gpu_create_contact_pair_impulse_query(body_pairs) + self._pairwise_contact_query_unique_hashes[query_key] = query_hash + + query = self.pairwise_contact_queries[query_key] + self.px.gpu_query_contact_pair_impulses(query) + # query.cuda_impulses is shape (num_unique_pairs * num_envs, 3) + pairwise_contact_impulses = query.cuda_impulses.torch().clone() + return pairwise_contact_impulses + else: + contacts = self.px.get_contacts() + pairwise_contact_impulses = sapien_utils.get_pairwise_contact_impulse( + contacts, obj1._bodies[0].entity, obj2._bodies[0].entity + ) + return common.to_tensor(pairwise_contact_impulses)[None, :] + + def get_pairwise_contact_forces( + self, obj1: Union[Actor, Link], obj2: Union[Actor, Link] + ): + """ + Get the force vectors between two actors/links. Returns force vector of shape (N, 3) + where N is the number of environments and 3 is the dimension of the force vector itself, + representing x, y, and z direction of force. + + Args: + obj1: Actor | Link + obj2: Actor | Link + """ + return self.get_pairwise_contact_impulses(obj1, obj2) / self.px.timestep + + @cached_property + def scene_offsets(self): + """torch tensor of shape (num_envs, 3) representing the offset of each scene in the world frame""" + return torch.tensor( + np.array( + [self.px.get_scene_offset(sub_scene) for sub_scene in self.sub_scenes] + ), + device=self.device, + ) + + @cached_property + def scene_offsets_np(self): + """numpy array of shape (num_envs, 3) representing the offset of each scene in the world frame""" + return np.array( + [self.px.get_scene_offset(sub_scene) for sub_scene in self.sub_scenes] + ) + + # -------------------------------------------------------------------------- # + # Simulation state (required for MPC) + # -------------------------------------------------------------------------- # + + def add_to_state_dict_registry(self, object: Union[Actor, Articulation]): + if isinstance(object, Actor): + assert ( + object.name not in self.state_dict_registry.actors + ), f"Object {object.name} already in state dict registry" + self.state_dict_registry.actors[object.name] = object + elif isinstance(object, Articulation): + assert ( + object.name not in self.state_dict_registry.articulations + ), f"Object {object.name} already in state dict registry" + self.state_dict_registry.articulations[object.name] = object + else: + raise ValueError(f"Expected Actor or Articulation, got {object}") + + def remove_from_state_dict_registry(self, object: Union[Actor, Articulation]): + if isinstance(object, Actor): + assert ( + object.name in self.state_dict_registry.actors + ), f"Object {object.name} not in state dict registry" + del self.state_dict_registry.actors[object.name] + elif isinstance(object, Articulation): + assert ( + object.name in self.state_dict_registry.articulations + ), f"Object {object.name} not in state dict registry" + del self.state_dict_registry.articulations[object.name] + else: + raise ValueError(f"Expected Actor or Articulation, got {object}") + + def get_sim_state(self) -> torch.Tensor: + """Get simulation state. Returns a dictionary with two nested dictionaries "actors" and "articulations". + In the nested dictionaries they map the actor/articulation name to a vector of shape (N, D) for N parallel + environments and D dimensions of padded state per environment. + + Note that static actor data are not included. It is expected that an environment reconstructs itself in a deterministic manner such that + the same static actors always have the same states""" + state_dict = dict() + state_dict["actors"] = dict() + state_dict["articulations"] = dict() + for actor in self.state_dict_registry.actors.values(): + if actor.px_body_type == "static": + continue + state_dict["actors"][actor.name] = actor.get_state().clone() + for articulation in self.state_dict_registry.articulations.values(): + state_dict["articulations"][ + articulation.name + ] = articulation.get_state().clone() + if len(state_dict["actors"]) == 0: + del state_dict["actors"] + if len(state_dict["articulations"]) == 0: + del state_dict["articulations"] + return state_dict + + def set_sim_state(self, state: Dict, env_idx: torch.Tensor = None): + if env_idx is not None: + prev_reset_mask = self._reset_mask.clone() + # safe guard against setting the wrong states + self._reset_mask[:] = False + self._reset_mask[env_idx] = True + + if "actors" in state: + for actor_id, actor_state in state["actors"].items(): + if len(actor_state.shape) == 1: + actor_state = actor_state[None, :] + # do not pass in env_idx to avoid redundant reset mask changes + self.state_dict_registry.actors[actor_id].set_state(actor_state, None) + if "articulations" in state: + for art_id, art_state in state["articulations"].items(): + if len(art_state.shape) == 1: + art_state = art_state[None, :] + self.state_dict_registry.articulations[art_id].set_state( + art_state, None + ) + if env_idx is not None: + self._reset_mask = prev_reset_mask + + # ---------------------------------------------------------------------------- # + # GPU Simulation Management + # ---------------------------------------------------------------------------- # + def _setup(self, enable_gpu: bool): + """ + Start the CPU/GPU simulation and allocate all buffers and initialize objects + """ + if enable_gpu: + if SAPIEN_RENDER_SYSTEM == "3.1": + for scene in self.sub_scenes: + scene.update_render() + self.px.gpu_init() + self.non_static_actors: List[Actor] = [] + # find non static actors, and set data indices that are now available after gpu_init was called + for actor in self.actors.values(): + if actor.px_body_type == "static": + continue + self.non_static_actors.append(actor) + if enable_gpu: + actor._body_data_index # only need to access this attribute to populate it + + for articulation in self.articulations.values(): + articulation._data_index + for link in articulation.links: + link._body_data_index + for actor in self.non_static_actors: + actor.set_pose(actor.initial_pose) + for articulation in self.articulations.values(): + articulation.set_pose(articulation.initial_pose) + + if enable_gpu: + self.px.cuda_rigid_body_data.torch()[:, 7:] = torch.zeros_like( + self.px.cuda_rigid_body_data.torch()[:, 7:] + ) # zero out all velocities + self.px.cuda_articulation_qvel.torch()[:, :] = torch.zeros_like( + self.px.cuda_articulation_qvel.torch() + ) # zero out all q velocities + + self.px.gpu_apply_rigid_dynamic_data() + self.px.gpu_apply_articulation_root_pose() + self.px.gpu_apply_articulation_root_velocity() + self.px.gpu_apply_articulation_qvel() + + self._gpu_sim_initialized = True + self.px.gpu_update_articulation_kinematics() + self._gpu_fetch_all() + + def _gpu_apply_all(self): + """ + Calls gpu_apply to update all body data, qpos, qvel, qf, and root poses + """ + assert ( + not self._needs_fetch + ), "Once _gpu_apply_all is called, you must call _gpu_fetch_all before calling _gpu_apply_all again\ + as otherwise there is undefined behavior that is likely impossible to debug" + self.px.gpu_apply_rigid_dynamic_data() + self.px.gpu_apply_articulation_qpos() + self.px.gpu_apply_articulation_qvel() + self.px.gpu_apply_articulation_qf() + self.px.gpu_apply_articulation_root_pose() + self.px.gpu_apply_articulation_root_velocity() + self.px.gpu_apply_articulation_target_position() + self.px.gpu_apply_articulation_target_velocity() + self._needs_fetch = True + + def _gpu_fetch_all(self): + """ + Queries simulation for all relevant GPU data. Note that this has some overhead. + Should only be called at most once per simulation step as this automatically queries all data for all + objects built in the scene. + """ + if len(self.non_static_actors) > 0: + self.px.gpu_fetch_rigid_dynamic_data() + + if len(self.articulations) > 0: + self.px.gpu_fetch_articulation_link_pose() + self.px.gpu_fetch_articulation_link_velocity() + self.px.gpu_fetch_articulation_qpos() + self.px.gpu_fetch_articulation_qvel() + self.px.gpu_fetch_articulation_qacc() + self.px.gpu_fetch_articulation_target_qpos() + self.px.gpu_fetch_articulation_target_qvel() + + self._needs_fetch = False + + # ---------------------------------------------------------------------------- # + # CPU/GPU sim Rendering Code + # ---------------------------------------------------------------------------- # + def _get_all_render_bodies( + self, + ) -> List[Tuple[sapien.render.RenderBodyComponent, int]]: + all_render_bodies = [] + for actor in self.actors.values(): + if actor.px_body_type == "static": + continue + all_render_bodies += [ + ( + entity.find_component_by_type(sapien.render.RenderBodyComponent), + entity.find_component_by_type( + physx.PhysxRigidDynamicComponent + ).gpu_pose_index, + ) + for entity in actor._objs + ] + for articulation in self.articulations.values(): + all_render_bodies += [ + ( + px_link.entity.find_component_by_type( + sapien.render.RenderBodyComponent + ), + px_link.gpu_pose_index, + ) + for link in articulation.links + for px_link in link._objs + ] + return all_render_bodies + + def _setup_gpu_rendering(self): + if SAPIEN_RENDER_SYSTEM == "3.1": + self._sapien_31_setup_gpu_rendering() + else: + self._sapien_setup_gpu_rendering() + + def _sapien_setup_gpu_rendering(self): + """ + Prepares the scene for GPU parallelized rendering to enable taking e.g. RGB images + """ + for rb, gpu_pose_index in self._get_all_render_bodies(): + if rb is not None: + for s in rb.render_shapes: + s.set_gpu_pose_batch_index(gpu_pose_index) + self.render_system_group = sapien.render.RenderSystemGroup( + [s.render_system for s in self.sub_scenes] + ) + self.render_system_group.set_cuda_poses(self.px.cuda_rigid_body_data) + + def _sapien_31_setup_gpu_rendering(self): + """ + Prepares the scene for GPU parallelized rendering to enable taking e.g. RGB images + """ + + px: physx.PhysxGpuSystem = self.px + + shape_pose_indices = [] + shapes = [] + scene_id = 0 + for scene in self.sub_scenes: + scene_id += 1 + for body in scene.render_system.render_bodies: + b = body.entity.find_component_by_type( + sapien.physx.PhysxRigidBodyComponent + ) + if b is None: + continue + for s in body.render_shapes: + shape_pose_indices.append(b.gpu_pose_index) + shapes.append(s) + + cam_pose_indices = [] + cams = [] + for cameras in self.sensors.values(): + assert isinstance(cameras, Camera), f"Expected Camera, got {cameras}" + for c in cameras.camera._render_cameras: + b = c.entity.find_component_by_type( + sapien.physx.PhysxRigidBodyComponent + ) + if b is None: + continue + cam_pose_indices.append(b.gpu_pose_index) + cams.append(c) + + sync_manager = sapien.render.GpuSyncManager() + sync_manager.set_cuda_poses(px.cuda_rigid_body_data) + sync_manager.set_render_shapes(shape_pose_indices, shapes) + sync_manager.set_cameras(cam_pose_indices, cams) + + self.render_system_group = sync_manager + + def _gpu_setup_sensors(self, sensors: Dict[str, BaseSensor]): + if SAPIEN_RENDER_SYSTEM == "3.1": + self._sapien_31_gpu_setup_sensors(sensors) + else: + self._sapien_gpu_setup_sensors(sensors) + + def _sapien_gpu_setup_sensors(self, sensors: Dict[str, BaseSensor]): + for name, sensor in sensors.items(): + if isinstance(sensor, Camera): + try: + camera_group = self.render_system_group.create_camera_group( + sensor.camera._render_cameras, + list(sensor.config.shader_config.texture_names.keys()), + ) + except RuntimeError as e: + raise RuntimeError( + "Unable to create GPU parallelized camera group. " + "If the error is about being unable to create a buffer, you are likely using too many Cameras. " + "Either use less cameras (via less parallel envs) and/or reduce the size of the cameras. " + "Another common cause is using a memory intensive shader, you can try using the 'minimal' shader " + "which optimizes for GPU memory but disables some advanced functionalities. " + "Another option is to avoid rendering with the rgb_array mode / using the human render cameras as " + "they can be more memory intensive as they typically have higher resolutions for the purposes of visualization." + ) from e + sensor.camera.camera_group = camera_group + self.camera_groups[name] = camera_group + else: + raise NotImplementedError( + f"This sensor {sensor} of type {sensor.__class__} has not been implemented yet on the GPU" + ) + + def _sapien_31_gpu_setup_sensors(self, sensors: dict[str, BaseSensor]): + for name, sensor in sensors.items(): + if isinstance(sensor, Camera): + batch_renderer = sapien.render.RenderManager( + sapien.render.get_shader_pack( + sensor.config.shader_config.shader_pack + ) + ) + batch_renderer.set_size(sensor.config.width, sensor.config.height) + batch_renderer.set_cameras(sensor.camera._render_cameras) + sensor.camera.camera_group = self.camera_groups[name] = batch_renderer + else: + raise NotImplementedError( + f"This sensor {sensor} of type {sensor.__class__} has not bget_picture_cuda implemented yet on the GPU" + ) + + def get_sensor_images( + self, obs: Dict[str, Any] + ) -> Dict[str, Dict[str, torch.Tensor]]: + """Get raw sensor data as images for visualization purposes.""" + sensor_data = dict() + for name, sensor in self.sensors.items(): + sensor_data[name] = sensor.get_images(obs[name]) + return sensor_data + + def get_human_render_camera_images( + self, camera_name: str = None + ) -> Dict[str, torch.Tensor]: + image_data = dict() + if self.gpu_sim_enabled: + if self.parallel_in_single_scene: + for name, camera in self.human_render_cameras.items(): + camera.camera._render_cameras[0].take_picture() + rgb = camera.get_obs( + rgb=True, depth=False, segmentation=False, position=False + )["rgb"] + image_data[name] = rgb + else: + for name, camera in self.human_render_cameras.items(): + if camera_name is not None and name != camera_name: + continue + assert camera.config.shader_config.shader_pack not in [ + "rt", + "rt-fast", + "rt-med", + ], "ray tracing shaders do not work with parallel rendering" + camera.capture() + rgb = camera.get_obs( + rgb=True, depth=False, segmentation=False, position=False + )["rgb"] + image_data[name] = rgb + else: + for name, camera in self.human_render_cameras.items(): + if camera_name is not None and name != camera_name: + continue + camera.capture() + rgb = camera.get_obs( + rgb=True, depth=False, segmentation=False, position=False + )["rgb"] + image_data[name] = rgb + return image_data diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8640e58444324cda0b8d3d1f2278e3c1b5cc3294 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/__init__.py @@ -0,0 +1,11 @@ +from .control import * +from .dexterity import * +from .digital_twins import * +from .drawing import * +from .empty_env import EmptyEnv +from .fmb import * +from .humanoid import * +from .mobile_manipulation import * +from .quadruped import * +from .rotate_cube import RotateCubeEnv +from .tabletop import * diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..118c0bd67e4f29a6cda1e1682b1959c075985afa --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__init__.py @@ -0,0 +1,3 @@ +# isort: off +from .rotate_valve import RotateValveEnv +from .rotate_single_object_in_hand import RotateSingleObjectInHand diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..863ea683292449d3848af0c3f117a9caf4672f7b Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__pycache__/rotate_single_object_in_hand.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__pycache__/rotate_single_object_in_hand.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c54bf5f613e6b142b213df896b5511a9c609f98c Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__pycache__/rotate_single_object_in_hand.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__pycache__/rotate_valve.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__pycache__/rotate_valve.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19ff6049022241f73e70c12d67558a47360b5ac7 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__pycache__/rotate_valve.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/rotate_single_object_in_hand.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/rotate_single_object_in_hand.py new file mode 100644 index 0000000000000000000000000000000000000000..a36e41ac62c04b589e436ec291587b3f7a4921e6 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/rotate_single_object_in_hand.py @@ -0,0 +1,373 @@ +from typing import Any, Dict, List, Union + +import numpy as np +import sapien +import torch +import torch.nn.functional as F + +from mani_skill import ASSET_DIR +from mani_skill.agents.robots import AllegroHandRightTouch +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.sensors.camera import CameraConfig +from mani_skill.utils import common, sapien_utils +from mani_skill.utils.building import actors +from mani_skill.utils.building.actors import build_cube +from mani_skill.utils.geometry.rotation_conversions import quaternion_apply +from mani_skill.utils.io_utils import load_json +from mani_skill.utils.registration import register_env +from mani_skill.utils.scene_builder.table import TableSceneBuilder +from mani_skill.utils.structs.actor import Actor +from mani_skill.utils.structs.pose import Pose, vectorize_pose +from mani_skill.utils.structs.types import Array, GPUMemoryConfig, SimConfig + + +class RotateSingleObjectInHand(BaseEnv): + agent: Union[AllegroHandRightTouch] + _clearance = 0.003 + hand_init_height = 0.25 + + def __init__( + self, + *args, + robot_init_qpos_noise=0.02, + obj_init_pos_noise=0.02, + difficulty_level: int = -1, + num_envs=1, + reconfiguration_freq=None, + **kwargs, + ): + self.robot_init_qpos_noise = robot_init_qpos_noise + self.obj_init_pos_noise = obj_init_pos_noise + self.obj_heights: torch.Tensor = torch.Tensor() + if ( + not isinstance(difficulty_level, int) + or difficulty_level >= 4 + or difficulty_level < 0 + ): + raise ValueError( + f"Difficulty level must be a int within 0-3, but get {difficulty_level}" + ) + self.difficulty_level = difficulty_level + if self.difficulty_level >= 2: + if reconfiguration_freq is None: + if num_envs == 1: + reconfiguration_freq = 1 + else: + reconfiguration_freq = 0 + super().__init__( + *args, + robot_uids="allegro_hand_right_touch", + num_envs=num_envs, + reconfiguration_freq=reconfiguration_freq, + **kwargs, + ) + + with torch.device(self.device): + self.prev_unit_vector = torch.zeros((self.num_envs, 3)) + self.cum_rotation_angle = torch.zeros((self.num_envs,)) + + @property + def _default_sim_config(self): + return SimConfig( + gpu_memory_config=GPUMemoryConfig( + max_rigid_contact_count=self.num_envs * max(1024, self.num_envs) * 8, + max_rigid_patch_count=self.num_envs * max(1024, self.num_envs) * 2, + found_lost_pairs_capacity=2**26, + ) + ) + + @property + def _default_sensor_configs(self): + pose = sapien_utils.look_at( + eye=[0.15, 0, 0.45], target=[-0.1, 0, self.hand_init_height] + ) + return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)] + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at([0.2, 0.4, 0.6], [0.0, 0.0, 0.3]) + return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100) + + def _load_scene(self, options: dict): + self.table_scene = TableSceneBuilder( + env=self, robot_init_qpos_noise=self.robot_init_qpos_noise + ) + self.table_scene.build() + + obj_heights = [] + if self.difficulty_level == 0: + self.obj = build_cube( + self.scene, + half_size=0.04, + color=np.array([255, 255, 255, 255]) / 255, + name="cube", + body_type="dynamic", + ) + obj_heights.append(0.03) + elif self.difficulty_level == 1: + half_sizes = (self._batched_episode_rng.randn() * 0.1 + 1) * 0.04 + self._objs: List[Actor] = [] + for i, half_size in enumerate(half_sizes): + builder = self.scene.create_actor_builder() + builder.add_box_collision( + half_size=[half_size] * 3, + ) + builder.add_box_visual( + half_size=[half_size] * 3, + material=sapien.render.RenderMaterial( + base_color=np.array([255, 255, 255, 255]) / 255, + ), + ) + builder.set_scene_idxs([i]) + self._objs.append(builder.build(name=f"cube-{i}")) + obj_heights.append(half_size) + self.obj = Actor.merge(self._objs, name="cube") + elif self.difficulty_level >= 2: + all_model_ids = np.array( + list( + load_json( + ASSET_DIR / "assets/mani_skill2_ycb/info_pick_v0.json" + ).keys() + ) + ) + model_ids = self._batched_episode_rng.choice(all_model_ids) + self._objs: List[Actor] = [] + for i, model_id in enumerate(model_ids): + builder = actors.get_actor_builder(self.scene, id=f"ycb:{model_id}") + builder.set_scene_idxs([i]) + self._objs.append(builder.build(name=f"{model_id}-{i}")) + self.obj = Actor.merge(self._objs, name="ycb_object") + else: + raise ValueError( + f"Difficulty level must be an int within 0-4, but get {self.difficulty_level}" + ) + + if self.difficulty_level < 2: + # for levels 0 and 1 we already know object heights. For other levels we need to compute them + self.obj_heights = common.to_tensor(obj_heights, device=self.device) + + def _after_reconfigure(self, options: dict): + if self.difficulty_level >= 2: + self.obj_heights = [] + for obj in self._objs: + collision_mesh = obj.get_first_collision_mesh() + # this value is used to set object pose so the bottom is at z=0 + self.obj_heights.append(-collision_mesh.bounding_box.bounds[0, 2]) + self.obj_heights = common.to_tensor(self.obj_heights, device=self.device) + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + self._initialize_actors(env_idx) + self._initialize_agent(env_idx) + + def _initialize_actors(self, env_idx: torch.Tensor): + with torch.device(self.device): + b = len(env_idx) + # Initialize object pose + self.table_scene.initialize(env_idx) + pose = self.obj.pose + new_pos = torch.randn((b, 3)) * self.obj_init_pos_noise + # hand_init_height is robot hand position while the 0.03 is a margin to ensure + new_pos[:, 2] = ( + torch.abs(new_pos[:, 2]) + self.hand_init_height + self.obj_heights + ) + pose.raw_pose[:, 0:3] = new_pos + pose.raw_pose[:, 3:7] = torch.tensor([[1, 0, 0, 0]]) + self.obj.set_pose(pose) + + # Initialize object axis + if self.difficulty_level <= 2: + axis = torch.ones((b,), dtype=torch.long) * 2 + else: + axis = torch.randint(0, 3, (b,), dtype=torch.long) + self.rot_dir = F.one_hot(axis, num_classes=3) + + # Sample a unit vector on the tangent plane of rotating axis + vector_axis = (axis + 1) % 3 + vector = F.one_hot(vector_axis, num_classes=3) + + # Initialize task related cache + self.unit_vector = vector + self.prev_unit_vector = vector.clone() + self.success_threshold = torch.pi * 4 + self.cum_rotation_angle = torch.zeros((b,)) + + # Controller parameters + stiffness = torch.tensor(self.agent.controller.config.stiffness) + damping = torch.tensor(self.agent.controller.config.damping) + force_limit = torch.tensor(self.agent.controller.config.force_limit) + self.controller_param = ( + stiffness.expand(b, self.agent.robot.dof[0]), + damping.expand(b, self.agent.robot.dof[0]), + force_limit.expand(b, self.agent.robot.dof[0]), + ) + + def _initialize_agent(self, env_idx: torch.Tensor): + with torch.device(self.device): + b = len(env_idx) + dof = self.agent.robot.dof + if isinstance(dof, torch.Tensor): + dof = dof[0] + init_qpos = torch.zeros((b, dof)) + self.agent.reset(init_qpos) + self.agent.robot.set_pose( + Pose.create_from_pq( + torch.tensor([0.0, 0, self.hand_init_height]), + torch.tensor([-0.707, 0, 0.707, 0]), + ) + ) + + def _get_obs_extra(self, info: Dict): + with torch.device(self.device): + obs = dict(rotate_dir=self.rot_dir) + if self.obs_mode_struct.use_state: + obs.update( + obj_pose=vectorize_pose(self.obj.pose), + obj_tip_vec=info["obj_tip_vec"].view(self.num_envs, 12), + ) + return obs + + def evaluate(self, **kwargs) -> dict: + with torch.device(self.device): + # 1. rotation angle + obj_pose = self.obj.pose + new_unit_vector = quaternion_apply(obj_pose.q, self.unit_vector) + new_unit_vector -= ( + torch.sum(new_unit_vector * self.rot_dir, dim=-1, keepdim=True) + * self.rot_dir + ) + new_unit_vector = new_unit_vector / torch.linalg.norm( + new_unit_vector, dim=-1, keepdim=True + ) + angle = torch.acos( + torch.clip( + torch.sum(new_unit_vector * self.prev_unit_vector, dim=-1), 0, 1 + ) + ) + # We do not expect the rotation angle for a single step to be so large + angle = torch.clip(angle, -torch.pi / 20, torch.pi / 20) + self.prev_unit_vector = new_unit_vector + + # 2. object velocity + obj_vel = torch.linalg.norm(self.obj.get_linear_velocity(), dim=-1) + + # 3. object falling + obj_fall = (obj_pose.p[:, 2] < self.hand_init_height - 0.05).to(torch.bool) + + # 4. finger object distance + tip_poses = [vectorize_pose(link.pose) for link in self.agent.tip_links] + tip_poses = torch.stack(tip_poses, dim=1) # (b, 4, 7) + obj_tip_vec = tip_poses[..., :3] - obj_pose.p[:, None, :] # (b, 4, 3) + obj_tip_dist = torch.linalg.norm(obj_tip_vec, dim=-1) # (b, 4) + + # 5. cum rotation angle + self.cum_rotation_angle += angle + success = self.cum_rotation_angle > self.success_threshold + + # 6. controller effort + qpos_target = self.agent.controller._target_qpos + qpos_error = qpos_target - self.agent.robot.qpos + qvel = self.agent.robot.qvel + qf = qpos_error * self.controller_param[0] - qvel * self.controller_param[1] + qf = torch.clip(qf, -self.controller_param[2], self.controller_param[2]) + power = torch.sum(qf * qvel, dim=-1) + + return dict( + rotation_angle=angle, + obj_vel=obj_vel, + obj_fall=obj_fall, + obj_tip_vec=obj_tip_vec, + obj_tip_dist=obj_tip_dist, + success=success, + qf=qf, + power=power, + fail=obj_fall, + ) + + def compute_dense_reward(self, obs: Any, action: Array, info: Dict): + # 1. rotation reward + angle = info["rotation_angle"] + reward = 20 * angle + + # 2. velocity penalty + obj_vel = info["obj_vel"] + reward += -0.1 * obj_vel + + # 3. falling penalty + obj_fall = info["obj_fall"] + reward += -50.0 * obj_fall + + # 4. effort penalty + power = torch.abs(info["power"]) + reward += -0.0003 * power + + # 5. torque penalty + qf = info["qf"] + qf_norm = torch.linalg.norm(qf, dim=-1) + reward += -0.0003 * qf_norm + + # 6. finger object distance reward + obj_tip_dist = info["obj_tip_dist"] + distance_rew = 0.1 / (0.02 + 4 * obj_tip_dist) + reward += torch.mean(torch.clip(distance_rew, 0, 1), dim=-1) + + return reward + + def compute_normalized_dense_reward(self, obs: Any, action: Array, info: Dict): + # this should be equal to compute_dense_reward / max possible reward + return self.compute_dense_reward(obs=obs, action=action, info=info) / 4.0 + + +@register_env("RotateSingleObjectInHandLevel0-v1", max_episode_steps=300) +class RotateSingleObjectInHandLevel0(RotateSingleObjectInHand): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + obj_init_pos_noise=0.02, + difficulty_level=0, + **kwargs, + ) + + +@register_env("RotateSingleObjectInHandLevel1-v1", max_episode_steps=300) +class RotateSingleObjectInHandLevel1(RotateSingleObjectInHand): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + obj_init_pos_noise=0.02, + difficulty_level=1, + **kwargs, + ) + + +@register_env( + "RotateSingleObjectInHandLevel2-v1", + max_episode_steps=300, + asset_download_ids=["ycb"], +) +class RotateSingleObjectInHandLevel2(RotateSingleObjectInHand): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + obj_init_pos_noise=0.02, + difficulty_level=2, + **kwargs, + ) + + +@register_env( + "RotateSingleObjectInHandLevel3-v1", + max_episode_steps=300, + asset_download_ids=["ycb"], +) +class RotateSingleObjectInHandLevel3(RotateSingleObjectInHand): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + obj_init_pos_noise=0.02, + difficulty_level=3, + **kwargs, + ) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/rotate_valve.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/rotate_valve.py new file mode 100644 index 0000000000000000000000000000000000000000..d99cfea166dbe9d740649d4bebdcef6552da9467 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/rotate_valve.py @@ -0,0 +1,312 @@ +from typing import Any, Dict, List, Union + +import numpy as np +import torch + +from mani_skill import logger +from mani_skill.agents.robots import DClaw +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.sensors.camera import CameraConfig +from mani_skill.utils import sapien_utils +from mani_skill.utils.building.articulations import build_robel_valve +from mani_skill.utils.geometry.rotation_conversions import axis_angle_to_quaternion +from mani_skill.utils.registration import register_env +from mani_skill.utils.scene_builder.table import TableSceneBuilder +from mani_skill.utils.structs.articulation import Articulation +from mani_skill.utils.structs.link import Link +from mani_skill.utils.structs.pose import Pose, vectorize_pose +from mani_skill.utils.structs.types import Array + + +class RotateValveEnv(BaseEnv): + agent: Union[DClaw] + _clearance = 0.003 + + def __init__( + self, + *args, + robot_init_qpos_noise=0.02, + valve_init_pos_noise=0.02, + difficulty_level: int = -1, + **kwargs, + ): + self.robot_init_qpos_noise = robot_init_qpos_noise + self.valve_init_pos_noise = valve_init_pos_noise + + if ( + not isinstance(difficulty_level, int) + or difficulty_level >= 5 + or difficulty_level < 0 + ): + raise ValueError( + f"Difficulty level must be a int within 0-4, but get {difficulty_level}" + ) + self.difficulty_level = difficulty_level + + # Task information + # For the simplest level 0, only quarter round will make it a success + # For the hardest level 4, rotate one rounds will make it a success + # For other intermediate level 1-3, the success threshold should be half round + if self.difficulty_level == 0: + self.success_threshold = torch.pi / 2 + elif self.difficulty_level == 4: + self.success_threshold = torch.pi * 2 + else: + self.success_threshold = torch.pi * 1 + + self.capsule_offset = 0.01 + + super().__init__(*args, robot_uids="dclaw", **kwargs) + + @property + def _default_sensor_configs(self): + pose = sapien_utils.look_at(eye=[0.3, 0, 0.3], target=[-0.1, 0, 0.05]) + return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)] + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at([0.2, 0.4, 0.4], [0.0, 0.0, 0.1]) + return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100) + + def _load_scene(self, options: dict): + self.table_scene = TableSceneBuilder( + env=self, robot_init_qpos_noise=self.robot_init_qpos_noise + ) + self.table_scene.build() + self._load_articulations() + + def _load_articulations(self): + # Robel valve + if self.difficulty_level == 0: + # Only tri-valve + valve_angles_list = [(0, np.pi / 3 * 2, np.pi / 3 * 4)] * self.num_envs + elif self.difficulty_level == 1: + base_angles = [ + np.arange(0, np.pi * 2, np.pi * 2 / 3), + np.arange(0, np.pi * 2, np.pi / 2), + np.arange(0, np.pi * 2, np.pi * 2 / 5), + ] + valve_angles_list = ( + base_angles * int(self.num_envs // 3) + + base_angles[: int(self.num_envs % 3)] + ) + elif self.difficulty_level == 2: + num_valve_head = self._batched_episode_rng.randint(3, 6) + valve_angles_list = [ + sample_valve_angles(num_head, self._batched_episode_rng[i]) + for i, num_head in enumerate(num_valve_head) + ] + elif self.difficulty_level >= 3: + num_valve_head = self._batched_episode_rng.randint(3, 6) + valve_angles_list = [ + sample_valve_angles(num_head, self._batched_episode_rng[i]) + for i, num_head in enumerate(num_valve_head) + ] + else: + raise ValueError( + f"Difficulty level must be a int within 0-4, but get {self.difficulty_level}" + ) + + valves: List[Articulation] = [] + capsule_lens = [] + valve_links = [] + for i, valve_angles in enumerate(valve_angles_list): + scene_idxs = [i] + if self.difficulty_level < 3: + valve, capsule_len = build_robel_valve( + self.scene, + valve_angles=valve_angles, + scene_idxs=scene_idxs, + name=f"valve_station_{i}", + ) + else: + scales = self._batched_episode_rng[i].randn(2) * 0.1 + 1 + valve, capsule_len = build_robel_valve( + self.scene, + valve_angles=valve_angles, + scene_idxs=scene_idxs, + name=f"valve_station_{i}", + radius_scale=scales[0], + capsule_radius_scale=scales[1], + ) + valves.append(valve) + valve_links.append(valve.links_map["valve"]) + capsule_lens.append(capsule_len) + self.valve = Articulation.merge(valves, "valve_station") + self.capsule_lens = torch.from_numpy(np.array(capsule_lens)).to(self.device) + self.valve_link = Link.merge(valve_links, name="valve") + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + self._initialize_actors(env_idx) + self._initialize_agent(env_idx) + + def _initialize_actors(self, env_idx: torch.Tensor): + with torch.device(self.device): + b = len(env_idx) + self.table_scene.initialize(env_idx) + + # Initialize task related information + if self.difficulty_level <= 3: + self.rotate_direction = torch.ones(b) + else: + self.rotate_direction = 1 - torch.randint(0, 2, (b,)) * 2 + + # Initialize the valve + xyz = torch.zeros((b, 3)) + xyz[:, :2].uniform_(-0.02, 0.02) + axis_angle = torch.zeros((b, 3)) + axis_angle[:, 2].uniform_(torch.pi / 6, torch.pi * 5 / 6) + pose = Pose.create_from_pq(xyz, axis_angle_to_quaternion(axis_angle)) + self.valve.set_pose(pose) + + qpos = torch.rand((b, 1)) * torch.pi * 2 - torch.pi + self.valve.set_qpos(qpos) + self.rest_qpos = qpos + + def _initialize_agent(self, env_idx: torch.Tensor): + with torch.device(self.device): + b = len(env_idx) + dof = self.agent.robot.dof + if isinstance(dof, torch.Tensor): + dof = dof[0] + + init_qpos = torch.zeros((b, dof)) + # set root joint qpos to avoid robot-object collision after reset + init_qpos[:, self.agent.root_joint_indices] = torch.tensor( + [0.7, -0.7, -0.7] + ) + init_qpos += torch.randn((b, dof)) * self.robot_init_qpos_noise + self.agent.reset(init_qpos) + self.agent.robot.set_pose( + Pose.create_from_pq( + torch.tensor([0.0, 0, 0.28]), torch.tensor([0, 0, -1, 0]) + ) + ) + + def _get_obs_extra(self, info: Dict): + with torch.device(self.device): + valve_qpos = self.valve.qpos + valve_qvel = self.valve.qvel + obs = dict( + rotate_dir=self.rotate_direction.to(torch.float32), + valve_qpos=valve_qpos, + valve_qvel=valve_qvel, + valve_x=torch.cos(valve_qpos[:, 0]), + valve_y=torch.sin(valve_qpos[:, 0]), + ) + if self.obs_mode_struct.use_state: + obs.update( + valve_pose=vectorize_pose(self.valve.pose), + ) + return obs + + def evaluate(self, **kwargs) -> dict: + valve_rotation = (self.valve.qpos - self.rest_qpos)[:, 0] + success = valve_rotation * self.rotate_direction > self.success_threshold + return dict(success=success, valve_rotation=valve_rotation) + + def compute_dense_reward(self, obs: Any, action: Array, info: Dict): + rotation = info["valve_rotation"] + qvel = self.valve.qvel + + # Distance between fingertips and the circle grouned by valve tips + tip_poses = self.agent.tip_poses # (b, 3, 7) + tip_pos = tip_poses[:, :, :2] # (b, 3, 2) + valve_pos = self.valve_link.pose.p[:, :2] # (b, 2) + valve_tip_dist = torch.linalg.norm(tip_pos - valve_pos[:, None, :], dim=-1) + desired_valve_tip_dist = self.capsule_lens[:, None] - self.capsule_offset + error = torch.norm(valve_tip_dist - desired_valve_tip_dist, dim=-1) + reward = 1 - torch.tanh(error * 10) + + directed_velocity = qvel[:, 0] * self.rotate_direction + reward += torch.tanh(5 * directed_velocity) * 4 + + motion_reward = torch.clip(rotation / torch.pi / 2, -1, 1) + reward += motion_reward + + return reward + + def compute_normalized_dense_reward(self, obs: Any, action: Array, info: Dict): + # this should be equal to compute_dense_reward / max possible reward + return self.compute_dense_reward(obs=obs, action=action, info=info) / 6.0 + + +def sample_valve_angles( + num_head: int, + random_state: np.random.RandomState, + min_angle_diff=np.pi / 6, + num_max_attempts=500, +): + for i in range(num_max_attempts): + angles = random_state.uniform(0, np.pi * 2, (num_head,)) + angles = np.sort(angles) + + # Append a 360 degree at the end of the list to check the last angle with the first one (0-degree) + diff = np.append(angles[1:], np.pi * 2) - angles + if np.min(diff) >= min_angle_diff: + return angles + + logger.warn( + f"sample_valve_angles reach max attempts {num_max_attempts}. Will use the default valve angles." + ) + return np.arange(0, np.pi * 2, np.pi * 2 / num_head) + + +@register_env("RotateValveLevel0-v1", max_episode_steps=80) +class RotateValveEnvLevel0(RotateValveEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + valve_init_pos_noise=0.02, + difficulty_level=0, + **kwargs, + ) + + +@register_env("RotateValveLevel1-v1", max_episode_steps=150) +class RotateValveEnvLevel1(RotateValveEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + valve_init_pos_noise=0.02, + difficulty_level=1, + **kwargs, + ) + + +@register_env("RotateValveLevel2-v1", max_episode_steps=150) +class RotateValveEnvLevel2(RotateValveEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + valve_init_pos_noise=0.02, + difficulty_level=2, + **kwargs, + ) + + +@register_env("RotateValveLevel3-v1", max_episode_steps=150) +class RotateValveEnvLevel3(RotateValveEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + valve_init_pos_noise=0.02, + difficulty_level=3, + **kwargs, + ) + + +@register_env("RotateValveLevel4-v1", max_episode_steps=300) +class RotateValveEnvLevel4(RotateValveEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + valve_init_pos_noise=0.02, + difficulty_level=4, + **kwargs, + ) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/empty_env.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/empty_env.py new file mode 100644 index 0000000000000000000000000000000000000000..35df9d047e1e3bf9f55437f204ff29dddf3a7ec3 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/empty_env.py @@ -0,0 +1,51 @@ +from typing import Dict + +import numpy as np +import sapien +import torch + +from mani_skill.agents.robots.fetch.fetch import Fetch +from mani_skill.agents.robots.panda.panda import Panda +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.sensors.camera import CameraConfig +from mani_skill.utils import sapien_utils +from mani_skill.utils.building.ground import build_ground +from mani_skill.utils.registration import register_env +from mani_skill.utils.structs.types import GPUMemoryConfig, SimConfig + + +@register_env("Empty-v1", max_episode_steps=200000) +class EmptyEnv(BaseEnv): + SUPPORTED_REWARD_MODES = ["none"] + """ + This is just a dummy environment for showcasing robots in a empty scene + """ + + def __init__(self, *args, robot_uids="panda", **kwargs): + super().__init__(*args, robot_uids=robot_uids, **kwargs) + + @property + def _default_sensor_configs(self): + pose = sapien_utils.look_at([1.25, -1.25, 1.5], [0.0, 0.0, 0.2]) + return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)] + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at([1.25, -1.25, 1.5], [0.0, 0.0, 0.2]) + return CameraConfig("render_camera", pose, 2048, 2048, 1, 0.01, 100) + + def _load_agent(self, options: dict): + super()._load_agent(options, sapien.Pose()) + + def _load_scene(self, options: dict): + self.ground = build_ground(self.scene) + self.ground.set_collision_group_bit(group=2, bit_idx=30, bit=1) + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + pass + + def evaluate(self): + return {} + + def _get_obs_extra(self, info: Dict): + return dict() diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/fmb/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/fmb/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b321dc3c5f03462066738ef64fdec4a76a702942 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/fmb/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/fmb/__pycache__/fmb.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/fmb/__pycache__/fmb.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f23d32bd6b5c405415fb6d73806cb1156802d988 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/fmb/__pycache__/fmb.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8f608e187bc0500224b7c3cdc6344df3817620c1 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/__init__.py @@ -0,0 +1,3 @@ +from .humanoid_pick_place import * +from .humanoid_stand import HumanoidStandEnv +from .transport_box import TransportBoxEnv diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/humanoid_stand.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/humanoid_stand.py new file mode 100644 index 0000000000000000000000000000000000000000..4d6717b1ab47d0ef6b8ef1abec0cd601de3a9f85 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/humanoid_stand.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Union + +import numpy as np +import sapien +import torch + +from mani_skill.agents.robots import UnitreeG1Simplified, UnitreeH1Simplified +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.sensors.camera import CameraConfig +from mani_skill.utils import common, sapien_utils +from mani_skill.utils.building.ground import build_ground +from mani_skill.utils.registration import register_env +from mani_skill.utils.structs.types import GPUMemoryConfig, SimConfig + + +class HumanoidStandEnv(BaseEnv): + SUPPORTED_REWARD_MODES = ["sparse", "none"] + + def __init__( + self, + *args, + robot_uids="unitree_h1_simplified", + robot_init_qpos_noise=0.02, + **kwargs + ): + self.robot_init_qpos_noise = robot_init_qpos_noise + super().__init__(*args, robot_uids=robot_uids, **kwargs) + + @property + def _default_sensor_configs(self): + return [] + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at([1.0, 1.0, 2.5], [0.0, 0.0, 0.75]) + return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100) + + def _load_scene(self, options: dict): + build_ground(self.scene) + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + pass + + def evaluate(self): + is_standing = self.agent.is_standing() + self.agent.is_fallen() + return {"is_standing": is_standing, "fail": ~is_standing} + + def _get_obs_extra(self, info: Dict): + return dict() + + def compute_sparse_reward(self, obs: Any, action: torch.Tensor, info: Dict): + return info["is_standing"] + + # def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict): + # return torch.zeros(self.num_envs, device=self.device) + + # def compute_normalized_dense_reward( + # self, obs: Any, action: torch.Tensor, info: Dict + # ): + # max_reward = 1.0 + # return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward + + +# Different robot embodiments require different configurations for optimal running and nicer render videos, we define those specifics below +@register_env("UnitreeH1Stand-v1", max_episode_steps=1000) +class UnitreeH1StandEnv(HumanoidStandEnv): + SUPPORTED_ROBOTS = ["unitree_h1_simplified"] + agent: Union[UnitreeH1Simplified] + + def __init__(self, *args, robot_uids="unitree_h1_simplified", **kwargs): + super().__init__(*args, robot_uids=robot_uids, **kwargs) + + @property + def _default_sim_config(self): + return SimConfig( + gpu_memory_config=GPUMemoryConfig( + max_rigid_contact_count=2**22, max_rigid_patch_count=2**21 + ) + ) + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at([1.0, 1.0, 2.5], [0.0, 0.0, 0.75]) + return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100) + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + with torch.device(self.device): + b = len(env_idx) + standing_keyframe = self.agent.keyframes["standing"] + random_qpos = ( + torch.randn(size=(b, self.agent.robot.dof[0]), dtype=torch.float) * 0.05 + ) + random_qpos += common.to_tensor(standing_keyframe.qpos, device=self.device) + self.agent.robot.set_qpos(random_qpos) + self.agent.robot.set_pose(sapien.Pose(p=[0, 0, 0.975])) + + +@register_env("UnitreeG1Stand-v1", max_episode_steps=1000) +class UnitreeG1StandEnv(HumanoidStandEnv): + SUPPORTED_ROBOTS = ["unitree_g1_simplified_legs"] + agent: Union[UnitreeG1Simplified] + + def __init__(self, *args, robot_uids="unitree_g1_simplified_legs", **kwargs): + super().__init__(*args, robot_uids=robot_uids, **kwargs) + + @property + def _default_sim_config(self): + return SimConfig( + gpu_memory_config=GPUMemoryConfig( + max_rigid_contact_count=2**22, max_rigid_patch_count=2**21 + ) + ) + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at([1.0, 1.0, 2.0], [0.0, 0.0, 0.75]) + return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100) + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + with torch.device(self.device): + b = len(env_idx) + standing_keyframe = self.agent.keyframes["standing"] + random_qpos = ( + torch.randn(size=(b, self.agent.robot.dof[0]), dtype=torch.float) * 0.05 + ) + random_qpos += common.to_tensor(standing_keyframe.qpos, device=self.device) + self.agent.robot.set_qpos(random_qpos) + self.agent.robot.set_pose(sapien.Pose(p=[0, 0, 0.755])) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/transport_box.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/transport_box.py new file mode 100644 index 0000000000000000000000000000000000000000..fa2aa9d92654e57c4f4217dac1e65fc08ae6a027 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/transport_box.py @@ -0,0 +1,311 @@ +import copy +import os +from pathlib import Path +from typing import Any, Dict + +import numpy as np +import sapien +import torch +from transforms3d.euler import euler2quat + +from mani_skill.agents.robots.unitree_g1.g1_upper_body import ( + UnitreeG1UpperBodyWithHeadCamera, +) +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.envs.utils import randomization +from mani_skill.sensors.camera import CameraConfig +from mani_skill.utils import common, sapien_utils +from mani_skill.utils.building import ground +from mani_skill.utils.registration import register_env +from mani_skill.utils.structs.pose import Pose +from mani_skill.utils.structs.types import GPUMemoryConfig, SceneConfig, SimConfig + + +@register_env("UnitreeG1TransportBox-v1", max_episode_steps=100) +class TransportBoxEnv(BaseEnv): + """ + **Task Description:** + A G1 humanoid robot must find a box on a table and transport it to the other table and place it there. + + **Randomizations:** + - the box's xy position is randomized in the region [-0.05, -0.05] x [0.2, 0.05] + - the box's z-axis rotation is randomized to a random angle in [0, np.pi/6] + + **Success Conditions:** + - the box is resting on top of the other table + """ + + _sample_video_link = "https://github.com/haosulab/ManiSkill/raw/main/figures/environment_demos/UnitreeG1TransportBox-v1_rt.mp4" + SUPPORTED_ROBOTS = ["unitree_g1_simplified_upper_body_with_head_camera"] + agent: UnitreeG1UpperBodyWithHeadCamera + + def __init__(self, *args, **kwargs): + self.init_robot_pose = copy.deepcopy( + UnitreeG1UpperBodyWithHeadCamera.keyframes["standing"].pose + ) + self.init_robot_pose.p = [-0.1, 0, 0.755] + self.init_robot_qpos = UnitreeG1UpperBodyWithHeadCamera.keyframes[ + "standing" + ].qpos.copy() + self.init_robot_qpos[4] = -1.25 + self.init_robot_qpos[3] = 1.25 + super().__init__( + *args, + robot_uids="unitree_g1_simplified_upper_body_with_head_camera", + **kwargs + ) + + @property + def _default_sim_config(self): + return SimConfig( + gpu_memory_config=GPUMemoryConfig( + max_rigid_contact_count=2**22, max_rigid_patch_count=2**21 + ), + scene_config=SceneConfig(contact_offset=0.02), + ) + + @property + def _default_sensor_configs(self): + pose = sapien_utils.look_at([1.0, 0.0, 1.6], [0, 0.0, 0.65]) + return [ + CameraConfig("base_camera", pose=pose, width=128, height=128, fov=np.pi / 3) + ] + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at([1.0, 0.0, 1.6], [0, 0.0, 0.65]) + return CameraConfig( + "render_camera", pose=pose, width=512, height=512, fov=np.pi / 3 + ) + + def _load_agent(self, options: dict): + super()._load_agent(options, sapien.Pose(p=[0, 0, 1])) + + def _load_scene(self, options: dict): + self.ground = ground.build_ground(self.scene, mipmap_levels=7) + # build two tables + + model_dir = Path( + os.path.join( + os.path.dirname(__file__), "../../../utils/scene_builder/table/assets" + ) + ) + table_model_file = str(model_dir / "table.glb") + scale = 1.2 + table_pose = sapien.Pose(q=euler2quat(0, 0, np.pi / 2)) + builder = self.scene.create_actor_builder() + builder.add_visual_from_file( + filename=table_model_file, + scale=[scale] * 3, + pose=sapien.Pose(q=euler2quat(0, 0, np.pi / 2)), + ) + builder.add_box_collision( + pose=sapien.Pose(p=[0, 0, 0.630612274 / 2]), + half_size=(1.658057143 / 2, 0.829028571 / 2, 0.630612274 / 2), + ) + builder.add_visual_from_file( + filename=table_model_file, scale=[scale] * 3, pose=table_pose + ) + builder.initial_pose = sapien.Pose(p=[0, 0.66, 0]) + self.table_1 = builder.build_static(name="table-1") + builder = self.scene.create_actor_builder() + builder.add_visual_from_file( + filename=table_model_file, + scale=[scale] * 3, + pose=sapien.Pose(q=euler2quat(0, 0, np.pi / 2)), + ) + builder.add_box_collision( + pose=sapien.Pose(p=[0, 0, 0.630612274 / 2]), + half_size=(1.658057143 / 2, 0.829028571 / 2, 0.630612274 / 2), + ) + builder.add_visual_from_file( + filename=table_model_file, scale=[scale] * 3, pose=table_pose + ) + builder.initial_pose = sapien.Pose(p=[0, -0.66, 0]) + self.table_2 = builder.build_static(name="table-2") + + builder = self.scene.create_actor_builder() + builder.add_box_collision(half_size=(0.18, 0.12, 0.12), density=200) + visual_file = os.path.join( + os.path.dirname(__file__), "assets/cardboard_box/textured.obj" + ) + builder.add_visual_from_file( + filename=visual_file, + scale=[0.12] * 3, + pose=sapien.Pose(q=euler2quat(0, 0, np.pi / 2)), + ) + builder.initial_pose = sapien.Pose(p=[-0.1, -0.37, 0.7508]) + self.box = builder.build(name="box") + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + with torch.device(self.device): + b = len(env_idx) + self.agent.robot.set_qpos(self.init_robot_qpos) + self.agent.robot.set_pose(self.init_robot_pose) + xyz = torch.zeros((b, 3)) + xyz[:, 2] = 0.7508 + xyz[:, 0] = randomization.uniform(-0.05, 0.2, size=(b,)) + xyz[:, 1] = randomization.uniform(-0.05, 0.05, size=(b,)) + xyz[:, :2] += torch.tensor([-0.1, -0.37]) + quat = randomization.random_quaternions( + n=b, device=self.device, lock_x=True, lock_y=True, bounds=(0, np.pi / 6) + ) + self.box.set_pose(Pose.create_from_pq(xyz, quat)) + + def evaluate(self): + # left_hand_grasped_box = self.agent.left_hand_is_grasping(self.box, max_angle=110) + # right_hand_grasped_box = self.agent.right_hand_is_grasping(self.box, max_angle=110) + l_contact_forces = ( + ( + self.scene.get_pairwise_contact_forces( + self.agent.robot.links_map["left_five_link"], self.box + ) + + self.scene.get_pairwise_contact_forces( + self.agent.robot.links_map["left_three_link"], self.box + ) + + self.scene.get_pairwise_contact_forces( + self.agent.robot.links_map["left_palm_link"], self.box + ) + ) + .abs() + .sum(dim=1) + ) + r_contact_forces = ( + ( + self.scene.get_pairwise_contact_forces( + self.agent.robot.links_map["right_five_link"], self.box + ) + + self.scene.get_pairwise_contact_forces( + self.agent.robot.links_map["right_three_link"], self.box + ) + + self.scene.get_pairwise_contact_forces( + self.agent.robot.links_map["right_palm_link"], self.box + ) + ) + .abs() + .sum(dim=1) + ) + left_hand_hit_box = l_contact_forces > 10 + right_hand_hit_box = r_contact_forces > 10 + # is grasping the box if both hands contact the box and the tcp of the hands are below the grasp points on the box. + box_grasped = ( + left_hand_hit_box + & right_hand_hit_box + & ( + self.agent.right_tcp.pose.p[:, 2] + < self.box_right_grasp_point.p[:, 2] + 0.04 + ) + & ( + self.agent.left_tcp.pose.p[:, 2] + < self.box_left_grasp_point.p[:, 2] + 0.04 + ) + ) + + # simply requires box to be resting somewhere on the correct table + box_at_correct_table_z = (0.751 > self.box.pose.p[:, 2]) & ( + self.box.pose.p[:, 2] > 0.750 + ) + box_at_correct_table_xy = ( + (0.78 > self.box.pose.p[:, 0]) + & (self.box.pose.p[:, 0] > -0.78) + & (1.0 > self.box.pose.p[:, 1]) + & (self.box.pose.p[:, 1] > 0.3) + ) + # box_at_correct_table = torch.linalg.norm(self.box.pose.p - torch.tensor([0, 0.66, 0.731], device=self.device), dim=1) < 0.05 + box_at_correct_table = box_at_correct_table_z & box_at_correct_table_xy + + facing_table_with_box = (-1.7 < self.agent.robot.qpos[:, 0]) & ( + self.agent.robot.qpos[:, 0] < -1.4 + ) # in this range the robot is probably facing the box on the left table. + return { + "success": ~box_grasped & box_at_correct_table, + "left_hand_hit_box": l_contact_forces > 0, + "right_hand_hit_box": r_contact_forces > 0, + "box_grasped": box_grasped, + "box_at_correct_table_xy": box_at_correct_table_xy, + "facing_table_with_box": facing_table_with_box, + } + + def _get_obs_extra(self, info: Dict): + obs = dict( + right_tcp_pose=self.agent.right_tcp.pose.raw_pose, + left_tcp_pose=self.agent.left_tcp.pose.raw_pose, + ) + + if "state" in self.obs_mode: + obs.update( + box_pose=self.box.pose.raw_pose, + right_tcp_to_box_pos=self.box.pose.p - self.agent.right_tcp.pose.p, + left_tcp_to_box_pos=self.box.pose.p - self.agent.left_tcp.pose.p, + ) + return obs + + @property + def box_right_grasp_point(self): + return self.box.pose * Pose.create_from_pq( + torch.tensor([-0.165, 0.07, 0.05], device=self.device) + ) + + @property + def box_left_grasp_point(self): + return self.box.pose * Pose.create_from_pq( + torch.tensor([0.165, 0.07, 0.05], device=self.device) + ) + + def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict): + # Stage 1, move to face the box on the table. Succeeds if facing_table_with_box + reward = 1 - torch.tanh((self.agent.robot.qpos[:, 0] + 1.4).abs()) + + # Stage 2, grasp the box stably. Succeeds if box_grasped + # encourage arms to go down essentially and for tcps to be close to the edge of the box + stage_2_reward = ( + 1 + + (1 - torch.tanh((self.agent.robot.qpos[:, 3]).abs())) / 4 + + (1 - torch.tanh((self.agent.robot.qpos[:, 4]).abs())) / 4 + + ( + 1 + - torch.tanh( + 3 + * torch.linalg.norm( + self.agent.right_tcp.pose.p - self.box_right_grasp_point.p, + dim=1, + ) + ) + ) + / 4 + + ( + 1 + - torch.tanh( + 3 + * torch.linalg.norm( + self.agent.left_tcp.pose.p - self.box_left_grasp_point.p, dim=1 + ) + ) + ) + / 4 + ) + reward[info["facing_table_with_box"]] = stage_2_reward[ + info["facing_table_with_box"] + ] + # Stage 3 transport box to above the other table, Succeeds if box_at_correct_table_xy + stage_3_reward = ( + 2 + 1 - torch.tanh((self.agent.robot.qpos[:, 0] - 1.4).abs() / 5) + ) + reward[info["box_grasped"]] = stage_3_reward[info["box_grasped"]] + # Stage 4 let go of the box. Succeeds if success (~box_grasped & box_at_correct_table) + stage_4_reward = ( + 3 + + (1 - torch.tanh((self.agent.robot.qpos[:, 3] - 1.25).abs())) / 2 + + (1 - torch.tanh((self.agent.robot.qpos[:, 4] + 1.25).abs())) / 2 + ) + reward[info["box_at_correct_table_xy"]] = stage_4_reward[ + info["box_at_correct_table_xy"] + ] + # encourage agent to stay close to a target qposition? + reward[info["success"]] = 5 + return reward + + def compute_normalized_dense_reward( + self, obs: Any, action: torch.Tensor, info: Dict + ): + return self.compute_dense_reward(obs, action, info) / 5 diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/mobile_manipulation/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/mobile_manipulation/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c861bc9f002b78dd29b62d6e3fdf958b40d80d1 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/mobile_manipulation/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/mobile_manipulation/open_cabinet_drawer.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/mobile_manipulation/open_cabinet_drawer.py new file mode 100644 index 0000000000000000000000000000000000000000..a03b1fc031c1f3ce12866ee0062e2d27ed07465a --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/mobile_manipulation/open_cabinet_drawer.py @@ -0,0 +1,366 @@ +from typing import Any, Dict, List, Optional, Union + +import numpy as np +import sapien +import sapien.physx as physx +import torch +import trimesh + +from mani_skill import PACKAGE_ASSET_DIR +from mani_skill.agents.robots import Fetch +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.envs.utils import randomization +from mani_skill.sensors.camera import CameraConfig +from mani_skill.utils import common, sapien_utils +from mani_skill.utils.building import actors, articulations +from mani_skill.utils.building.ground import build_ground +from mani_skill.utils.geometry.geometry import transform_points +from mani_skill.utils.io_utils import load_json +from mani_skill.utils.registration import register_env +from mani_skill.utils.structs import Articulation, Link, Pose +from mani_skill.utils.structs.types import GPUMemoryConfig, SimConfig + +CABINET_COLLISION_BIT = 29 + + +# TODO (stao): we need to cut the meshes of all the cabinets in this dataset for gpu sim, there may be some wierd physics +# that may happen although it seems okay for state based RL +@register_env( + "OpenCabinetDrawer-v1", + asset_download_ids=["partnet_mobility_cabinet"], + max_episode_steps=100, +) +class OpenCabinetDrawerEnv(BaseEnv): + """ + **Task Description:** + Use the Fetch mobile manipulation robot to move towards a target cabinet and open the target drawer out. + + **Randomizations:** + - Robot is randomly initialized 1.6 to 1.8 meters away from the cabinet and positioned to face it + - Robot's base orientation is randomized by -9 to 9 degrees + - The cabinet selected to manipulate is randomly sampled from all PartnetMobility cabinets that have drawers + - The drawer to open is randomly sampled from all drawers available to open + + **Success Conditions:** + - The drawer is open at least 90% of the way, and the angular/linear velocities of the drawer link are small + + **Goal Specification:** + - 3D goal position centered at the center of mass of the handle mesh on the drawer to open (also visualized in human renders with a sphere). + """ + + _sample_video_link = "https://github.com/haosulab/ManiSkill/raw/main/figures/environment_demos/OpenCabinetDrawer-v1_rt.mp4" + + SUPPORTED_ROBOTS = ["fetch"] + agent: Union[Fetch] + handle_types = ["prismatic"] + TRAIN_JSON = ( + PACKAGE_ASSET_DIR / "partnet_mobility/meta/info_cabinet_drawer_train.json" + ) + + min_open_frac = 0.75 + + def __init__( + self, + *args, + robot_uids="fetch", + robot_init_qpos_noise=0.02, + reconfiguration_freq=None, + num_envs=1, + **kwargs, + ): + self.robot_init_qpos_noise = robot_init_qpos_noise + train_data = load_json(self.TRAIN_JSON) + self.all_model_ids = np.array(list(train_data.keys())) + # self.all_model_ids = np.array(["1004", "1004"]) + if reconfiguration_freq is None: + # if not user set, we pick a number + if num_envs == 1: + reconfiguration_freq = 1 + else: + reconfiguration_freq = 0 + super().__init__( + *args, + robot_uids=robot_uids, + reconfiguration_freq=reconfiguration_freq, + num_envs=num_envs, + **kwargs, + ) + + @property + def _default_sim_config(self): + return SimConfig( + spacing=5, + gpu_memory_config=GPUMemoryConfig( + max_rigid_contact_count=2**21, max_rigid_patch_count=2**19 + ), + ) + + @property + def _default_sensor_configs(self): + return [] + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at(eye=[-1.8, -1.3, 1.8], target=[-0.3, 0.5, 0]) + return CameraConfig( + "render_camera", pose=pose, width=512, height=512, fov=1, near=0.01, far=100 + ) + + def _load_agent(self, options: dict): + super()._load_agent(options, sapien.Pose(p=[1, 0, 0])) + + def _load_scene(self, options: dict): + self.ground = build_ground(self.scene) + # temporarily turn off the logging as there will be big red warnings + # about the cabinets having oblong meshes which we ignore for now. + sapien.set_log_level("off") + self._load_cabinets(self.handle_types) + sapien.set_log_level("warn") + from mani_skill.agents.robots.fetch import FETCH_WHEELS_COLLISION_BIT + + self.ground.set_collision_group_bit( + group=2, bit_idx=FETCH_WHEELS_COLLISION_BIT, bit=1 + ) + self.ground.set_collision_group_bit( + group=2, bit_idx=CABINET_COLLISION_BIT, bit=1 + ) + + def _load_cabinets(self, joint_types: List[str]): + # we sample random cabinet model_ids with numpy as numpy is always deterministic based on seed, regardless of + # GPU/CPU simulation backends. This is useful for replaying demonstrations. + model_ids = self._batched_episode_rng.choice(self.all_model_ids) + link_ids = self._batched_episode_rng.randint(0, 2**31) + + self._cabinets = [] + handle_links: List[List[Link]] = [] + handle_links_meshes: List[List[trimesh.Trimesh]] = [] + for i, model_id in enumerate(model_ids): + # partnet-mobility is a dataset source and the ids are the ones we sampled + # we provide tools to easily create the articulation builder like so by querying + # the dataset source and unique ID + cabinet_builder = articulations.get_articulation_builder( + self.scene, f"partnet-mobility:{model_id}" + ) + cabinet_builder.set_scene_idxs(scene_idxs=[i]) + cabinet_builder.initial_pose = sapien.Pose(p=[0, 0, 0], q=[1, 0, 0, 0]) + cabinet = cabinet_builder.build(name=f"{model_id}-{i}") + self.remove_from_state_dict_registry(cabinet) + # this disables self collisions by setting the group 2 bit at CABINET_COLLISION_BIT all the same + # that bit is also used to disable collision with the ground plane + for link in cabinet.links: + link.set_collision_group_bit( + group=2, bit_idx=CABINET_COLLISION_BIT, bit=1 + ) + self._cabinets.append(cabinet) + handle_links.append([]) + handle_links_meshes.append([]) + + # TODO (stao): At the moment code for selecting semantic parts of articulations + # is not very simple. Will be improved in the future as we add in features that + # support part and mesh-wise annotations in a standard querable format + for link, joint in zip(cabinet.links, cabinet.joints): + if joint.type[0] in joint_types: + handle_links[-1].append(link) + # save the first mesh in the link object that correspond with a handle + handle_links_meshes[-1].append( + link.generate_mesh( + filter=lambda _, render_shape: "handle" + in render_shape.name, + mesh_name="handle", + )[0] + ) + + # we can merge different articulations/links with different degrees of freedoms into a single view/object + # allowing you to manage all of them under one object and retrieve data like qpos, pose, etc. all together + # and with high performance. Note that some properties such as qpos and qlimits are now padded. + self.cabinet = Articulation.merge(self._cabinets, name="cabinet") + self.add_to_state_dict_registry(self.cabinet) + self.handle_link = Link.merge( + [links[link_ids[i] % len(links)] for i, links in enumerate(handle_links)], + name="handle_link", + ) + # store the position of the handle mesh itself relative to the link it is apart of + self.handle_link_pos = common.to_tensor( + np.array( + [ + meshes[link_ids[i] % len(meshes)].bounding_box.center_mass + for i, meshes in enumerate(handle_links_meshes) + ] + ), + device=self.device, + ) + + self.handle_link_goal = actors.build_sphere( + self.scene, + radius=0.02, + color=[0, 1, 0, 1], + name="handle_link_goal", + body_type="kinematic", + add_collision=False, + initial_pose=sapien.Pose(p=[0, 0, 0], q=[1, 0, 0, 0]), + ) + + def _after_reconfigure(self, options): + # To spawn cabinets in the right place, we need to change their z position such that + # the bottom of the cabinet sits at z=0 (the floor). Luckily the partnet mobility dataset is made such that + # the negative of the lower z-bound of the collision mesh bounding box is the right value + + # this code is in _after_reconfigure since retrieving collision meshes requires the GPU to be initialized + # which occurs after the initial reconfigure call (after self._load_scene() is called) + self.cabinet_zs = [] + for cabinet in self._cabinets: + collision_mesh = cabinet.get_first_collision_mesh() + self.cabinet_zs.append(-collision_mesh.bounding_box.bounds[0, 2]) + self.cabinet_zs = common.to_tensor(self.cabinet_zs, device=self.device) + + # get the qmin qmax values of the joint corresponding to the selected links + target_qlimits = self.handle_link.joint.limits # [b, 1, 2] + qmin, qmax = target_qlimits[..., 0], target_qlimits[..., 1] + self.target_qpos = qmin + (qmax - qmin) * self.min_open_frac + + def handle_link_positions(self, env_idx: Optional[torch.Tensor] = None): + if env_idx is None: + return transform_points( + self.handle_link.pose.to_transformation_matrix().clone(), + common.to_tensor(self.handle_link_pos, device=self.device), + ) + return transform_points( + self.handle_link.pose[env_idx].to_transformation_matrix().clone(), + common.to_tensor(self.handle_link_pos[env_idx], device=self.device), + ) + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + + with torch.device(self.device): + b = len(env_idx) + xy = torch.zeros((b, 3)) + xy[:, 2] = self.cabinet_zs[env_idx] + self.cabinet.set_pose(Pose.create_from_pq(p=xy)) + + # initialize robot + if self.robot_uids == "fetch": + qpos = torch.tensor( + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -np.pi / 4, + 0, + np.pi / 4, + 0, + np.pi / 3, + 0, + 0.015, + 0.015, + ] + ) + qpos = qpos.repeat(b).reshape(b, -1) + dist = randomization.uniform(1.6, 1.8, size=(b,)) + theta = randomization.uniform(0.9 * torch.pi, 1.1 * torch.pi, size=(b,)) + xy = torch.zeros((b, 2)) + xy[:, 0] += torch.cos(theta) * dist + xy[:, 1] += torch.sin(theta) * dist + qpos[:, :2] = xy + noise_ori = randomization.uniform( + -0.05 * torch.pi, 0.05 * torch.pi, size=(b,) + ) + ori = (theta - torch.pi) + noise_ori + qpos[:, 2] = ori + self.agent.robot.set_qpos(qpos) + self.agent.robot.set_pose(sapien.Pose()) + # close all the cabinets. We know beforehand that lower qlimit means "closed" for these assets. + qlimits = self.cabinet.get_qlimits() # [b, self.cabinet.max_dof, 2]) + self.cabinet.set_qpos(qlimits[env_idx, :, 0]) + self.cabinet.set_qvel(self.cabinet.qpos[env_idx] * 0) + + # NOTE (stao): This is a temporary work around for the issue where the cabinet drawers/doors might open + # themselves on the first step. It's unclear why this happens on GPU sim only atm. + # moreover despite setting qpos/qvel to 0, the cabinets might still move on their own a little bit. + # this may be due to oblong meshes. + if self.gpu_sim_enabled: + self.scene._gpu_apply_all() + self.scene.px.gpu_update_articulation_kinematics() + self.scene.px.step() + self.scene._gpu_fetch_all() + + self.handle_link_goal.set_pose( + Pose.create_from_pq(p=self.handle_link_positions(env_idx)) + ) + + def _after_control_step(self): + # after each control step, we update the goal position of the handle link + # for GPU sim we need to update the kinematics data to get latest pose information for up to date link poses + # and fetch it, followed by an apply call to ensure the GPU sim is up to date + if self.gpu_sim_enabled: + self.scene.px.gpu_update_articulation_kinematics() + self.scene._gpu_fetch_all() + self.handle_link_goal.set_pose( + Pose.create_from_pq(p=self.handle_link_positions()) + ) + if self.gpu_sim_enabled: + self.scene._gpu_apply_all() + + def evaluate(self): + # even though self.handle_link is a different link across different articulations + # we can still fetch a joint that represents the parent joint of all those links + # and easily get the qpos value. + open_enough = self.handle_link.joint.qpos >= self.target_qpos + handle_link_pos = self.handle_link_positions() + + link_is_static = ( + torch.linalg.norm(self.handle_link.angular_velocity, axis=1) <= 1 + ) & (torch.linalg.norm(self.handle_link.linear_velocity, axis=1) <= 0.1) + return { + "success": open_enough & link_is_static, + "handle_link_pos": handle_link_pos, + "open_enough": open_enough, + } + + def _get_obs_extra(self, info: Dict): + obs = dict( + tcp_pose=self.agent.tcp.pose.raw_pose, + ) + + if "state" in self.obs_mode: + obs.update( + tcp_to_handle_pos=info["handle_link_pos"] - self.agent.tcp.pose.p, + target_link_qpos=self.handle_link.joint.qpos, + target_handle_pos=info["handle_link_pos"], + ) + return obs + + def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict): + tcp_to_handle_dist = torch.linalg.norm( + self.agent.tcp.pose.p - info["handle_link_pos"], axis=1 + ) + reaching_reward = 1 - torch.tanh(5 * tcp_to_handle_dist) + amount_to_open_left = torch.div( + self.target_qpos - self.handle_link.joint.qpos, self.target_qpos + ) + open_reward = 2 * (1 - amount_to_open_left) + reaching_reward[ + amount_to_open_left < 0.999 + ] = 2 # if joint opens even a tiny bit, we don't need reach reward anymore + # print(open_reward.shape) + open_reward[info["open_enough"]] = 3 # give max reward here + reward = reaching_reward + open_reward + reward[info["success"]] = 5.0 + return reward + + def compute_normalized_dense_reward( + self, obs: Any, action: torch.Tensor, info: Dict + ): + max_reward = 5.0 + return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward + + +@register_env("OpenCabinetDoor-v1", max_episode_steps=100) +class OpenCabinetDoorEnv(OpenCabinetDrawerEnv): + TRAIN_JSON = ( + PACKAGE_ASSET_DIR / "partnet_mobility/meta/info_cabinet_door_train.json" + ) + handle_types = ["revolute", "revolute_unwrapped"] diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/rotate_cube.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/rotate_cube.py new file mode 100644 index 0000000000000000000000000000000000000000..bc2bc0c4ffb2d88ade5142f5275ee7fbe4bc82d5 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/rotate_cube.py @@ -0,0 +1,403 @@ +from typing import Any, Dict, Tuple + +import numpy as np +import torch +import torch.random + +from mani_skill import PACKAGE_ASSET_DIR +from mani_skill.agents.robots import TriFingerPro +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.envs.utils.randomization.pose import random_quaternions +from mani_skill.sensors.camera import CameraConfig +from mani_skill.utils import common, sapien_utils +from mani_skill.utils.building import ActorBuilder, actors +from mani_skill.utils.building.ground import build_ground +from mani_skill.utils.registration import register_env +from mani_skill.utils.structs import Actor, Articulation, Pose +from mani_skill.utils.structs.types import Array, GPUMemoryConfig, SimConfig + + +class RotateCubeEnv(BaseEnv): + """ + Modified from https://github.com/NVIDIA-Omniverse/IsaacGymEnvs/blob/main/isaacgymenvs/tasks/trifinger.py + https://github.com/NVIDIA-Omniverse/IsaacGymEnvs/blob/main/isaacgymenvs/cfg/task/Trifinger.yaml + """ + + SUPPORTED_ROBOTS = ["trifingerpro"] + + # Specify some supported robot types + agent: TriFingerPro + + # Specify default simulation/gpu memory configurations. + sim_config = SimConfig( + gpu_memory_config=GPUMemoryConfig( + found_lost_pairs_capacity=2**25, max_rigid_patch_count=2**18 + ) + ) + + # set some commonly used values + goal_radius = 0.02 + cube_half_size = 0.02 + + # radius of the area + ARENA_RADIUS = 0.195 + size = 0.065 # m + max_len = 0.065 + # 3D radius of the cuboid + radius_3d = max_len * np.sqrt(3) / 2 + # compute distance from wall to the center + max_com_distance_to_center = ARENA_RADIUS - radius_3d + # minimum and maximum height for spawning the object + min_height = 0.065 / 2 + max_height = 0.1 + + def __init__( + self, + *args, + robot_uids="trifingerpro", + robot_init_qpos_noise=0.02, + difficulty_level: int = 4, + **kwargs, + ): + self.robot_init_qpos_noise = robot_init_qpos_noise + + if ( + not isinstance(difficulty_level, int) + or difficulty_level >= 5 + or difficulty_level < 0 + ): + raise ValueError( + f"Difficulty level must be a int within 0-4, but get {difficulty_level}" + ) + + self.difficulty_level = difficulty_level + super().__init__(*args, robot_uids=robot_uids, **kwargs) + + @property + def _default_sensor_configs(self): + pose = sapien_utils.look_at(eye=(0.7, 0.0, 0.7), target=(0.0, 0.0, 0.0)) + return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)] + + @property + def _default_human_render_camera_configs(self): + pose = sapien_utils.look_at(eye=(0.7, 0.0, 0.7), target=(0.0, 0.0, 0.0)) + return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100) + + def _load_scene(self, options: dict): + self.ground = build_ground(self.scene, altitude=0) + loader1 = self.scene.create_urdf_loader() + loader1.fix_root_link = True + loader1.name = "table" + urdf_path = f"{PACKAGE_ASSET_DIR}/robots/trifinger/table_without_border.urdf" + table: Articulation = loader1.load(urdf_path) + + builder: ActorBuilder = self.scene.create_actor_builder() + high_table_boundary_file_name = f"{PACKAGE_ASSET_DIR}/robots/trifinger/robot_properties_fingers/meshes/high_table_boundary.stl" + builder.add_nonconvex_collision_from_file( + filename=high_table_boundary_file_name, scale=[1, 1, 1], material=None + ) + builder.add_visual_from_file(filename=high_table_boundary_file_name) + table_boundary: Actor = builder.build_static("table2") + + self.obj = actors.build_colorful_cube( + self.scene, + half_size=self.size / 2, + color=np.array([169, 42, 12, 255]) / 255, + name="cube", + body_type="dynamic", + add_collision=True, + ) + + self.obj_goal = actors.build_colorful_cube( + self.scene, + half_size=self.size / 2, + color=np.array([12, 160, 42, 255]) / 255, + name="cube_goal", + body_type="kinematic", + add_collision=False, + ) + self._hidden_objects.append(self.obj_goal) + + def _initialize_actors(self, env_idx: torch.Tensor): + with torch.device(self.device): + b = len(env_idx) + xyz = torch.zeros((b, 3)) + xyz[..., 2] = self.size / 2 + 0.005 + obj_pose = Pose.create_from_pq(p=xyz, q=[1, 0, 0, 0]) + self.obj.set_pose(obj_pose) + pos, orn = self._sample_object_goal_poses( + env_idx, difficulty=self.difficulty_level + ) + self.obj_goal.set_pose(Pose.create_from_pq(p=pos, q=orn)) + self.prev_norms = None + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + self._initialize_actors(env_idx) + self._initialize_agent(env_idx) + + def _sample_object_goal_poses(self, env_idx: torch.Tensor, difficulty: int): + """Sample goal poses for the cube and sets them into the desired goal pose buffer. + + Args: + instances: A tensor constraining indices of environment instances to reset. + difficulty: Difficulty level. The higher, the more difficult is the goal. + + Possible levels are: + - 0: Random goal position on the table, no orientation. + - 1: Random goal position on the table, including yaw orientation. + - 2: Fixed goal position in the air with x,y = 0. No orientation. + - 3: Random goal position in the air, no orientation. + - 4: Random goal pose in the air, including orientation. + """ + b = len(env_idx) + default_orn = torch.tensor( + [1.0, 0.0, 0.0, 0.0], dtype=torch.float, device=self.device + ).repeat(b, 1) + + def random_xy() -> Tuple[torch.Tensor, torch.Tensor]: + """Returns sampled uniform positions in circle (https://stackoverflow.com/a/50746409)""" + # sample radius of circle + radius = torch.sqrt(torch.rand(b, dtype=torch.float, device=self.device)) + radius *= self.max_com_distance_to_center + # sample theta of point + theta = 2 * np.pi * torch.rand(b, dtype=torch.float, device=self.device) + # x,y-position of the cube + x = radius * torch.cos(theta) + y = radius * torch.sin(theta) + + return x, y + + def random_z(min_height: float, max_height: float) -> torch.Tensor: + """Returns sampled height of the goal object.""" + z = torch.rand(b, dtype=torch.float, device=self.device) + z = (max_height - min_height) * z + min_height + return z + + if difficulty == 0: + # Random goal position on the table, no orientation. + pos_x, pos_y = random_xy() + pos_z = self.size / 2 + orientation = default_orn + elif difficulty == 1: + # For initialization + pos_x, pos_y = random_xy() + pos_z = self.size / 2 + orientation = random_quaternions( + b, lock_x=True, lock_y=True, device=self.device + ) + elif difficulty == 2: + # Fixed goal position in the air with x,y = 0. No orientation. + pos_x, pos_y = 0.0, 0.0 + pos_z = self.min_height + 0.05 + orientation = default_orn + elif difficulty == 3: + # Random goal position in the air, no orientation. + pos_x, pos_y = random_xy() + pos_z = random_z(min_height=self.min_height, max_height=self.max_height) + orientation = default_orn + elif difficulty == 4: + # Random goal pose in the air, including orientation. + # Note: Set minimum height such that the cube does not intersect with the + # ground in any orientation + + # pick x, y, z according to the maximum height / radius at the current point + # in the cirriculum + pos_x, pos_y = random_xy() + pos_z = random_z(min_height=self.radius_3d, max_height=self.max_height) + orientation = random_quaternions(b, device=self.device) + else: + msg = f"Invalid difficulty index for task: {difficulty}." + raise ValueError(msg) + + pos_tensor = torch.zeros((b, 3), dtype=torch.float, device=self.device) + pos_tensor[:, 0] = pos_x + pos_tensor[:, 1] = pos_y + pos_tensor[:, 2] = pos_z + return pos_tensor, orientation + + def evaluate(self): + obj_p = self.obj.pose.p + goal_p = self.obj_goal.pose.p + obj_q = self.obj.pose.q + goal_q = self.obj_goal.pose.q + + is_obj_pos_close_to_goal = ( + torch.linalg.norm(obj_p - goal_p, axis=1) < self.goal_radius + ) + + is_obj_q_close_to_goal = common.quat_diff_rad(obj_q, goal_q) < 0.1 + + is_success = is_obj_pos_close_to_goal & is_obj_q_close_to_goal + + return { + "success": is_success, + } + + def _initialize_agent(self, env_idx: torch.Tensor): + with torch.device(self.device): + b = len(env_idx) + dof = self.agent.robot.dof + if isinstance(dof, torch.Tensor): + dof = dof[0] + + init_qpos = torch.zeros((b, dof)) + init_qpos += torch.randn((b, dof)) * self.robot_init_qpos_noise + self.agent.reset(init_qpos) + self.agent.robot.set_pose( + Pose.create_from_pq( + torch.tensor([0.0, 0, self.size / 2 + 0.022]), + torch.tensor([1, 0, 0, 0]), + ) + ) + + def _get_obs_extra(self, info: Dict): + obs = dict( + goal_pos=self.obj_goal.pose.p, + goal_q=self.obj_goal.pose.q, + ) + if self.obs_mode_struct.use_state: + obs.update( + obj_p=self.obj.pose.p, + obj_q=self.obj.pose.q, + ) + return obs + + def compute_dense_reward(self, obs: Any, action: Array, info: Dict): + obj_pos = self.obj.pose.p + obj_q = self.obj.pose.q + goal_pos = self.obj_goal.pose.p + goal_q = self.obj_goal.pose.q + + object_dist_weight = 5 + object_rot_weight = 5 + + # Reward penalising finger movement + + tip_poses = self.agent.tip_poses + # shape (N, 3 + 4, 3 fingers) + + finger_reach_object_dist_1 = torch.norm( + tip_poses[:, :3, 0] - obj_pos, p=2, dim=-1 + ) + finger_reach_object_dist_2 = torch.norm( + tip_poses[:, :3, 1] - obj_pos, p=2, dim=-1 + ) + finger_reach_object_dist_3 = torch.norm( + tip_poses[:, :3, 2] - obj_pos, p=2, dim=-1 + ) + finger_reach_object_reward1 = 1 - torch.tanh(5 * finger_reach_object_dist_1) + finger_reach_object_reward2 = 1 - torch.tanh(5 * finger_reach_object_dist_2) + finger_reach_object_reward3 = 1 - torch.tanh(5 * finger_reach_object_dist_3) + finger_reach_object_reward = ( + object_dist_weight + * ( + finger_reach_object_reward1 + + finger_reach_object_reward2 + + finger_reach_object_reward3 + ) + / 3 + ) + + # Reward for object distance + object_dist = torch.norm(obj_pos - goal_pos, p=2, dim=-1) + + init_xyz_tensor = torch.tensor( + [0, 0, 0.032], dtype=torch.float, device=self.device + ).reshape(1, 3) + init_z_dist = torch.norm( + init_xyz_tensor + - goal_pos[ + ..., + ], + p=2, + dim=-1, + ) + + # object_dist_reward = object_dist_weight * dt * lgsk_kernel(object_dist, scale=50., eps=2.) + + object_dist_reward = 1 - torch.tanh(5 * object_dist) + object_init_dist_reward = 1 - torch.tanh(5 * init_z_dist) + object_dist_reward -= object_init_dist_reward + + init_z_tensor = torch.tensor( + [0.032], dtype=torch.float, device=self.device + ).reshape(1, 1) + object_z_dist = torch.norm(obj_pos[..., 2:3] - goal_pos[..., 2:3], p=2, dim=-1) + init_z_dist = torch.norm(init_z_tensor - goal_pos[..., 2:3], p=2, dim=-1) + object_lift_reward = 5 * ((1 - torch.tanh(5 * object_z_dist))) + object_init_z_reward = 5 * ((1 - torch.tanh(5 * init_z_dist))) + + object_lift_reward -= object_init_z_reward + + # extract quaternion orientation + angles = common.quat_diff_rad(obj_q, goal_q) + object_rot_reward = -1 * torch.abs(angles) + pose_reward = ( + object_dist_weight * (object_dist_reward + object_lift_reward) + + object_rot_weight * object_rot_reward + ) + total_reward = finger_reach_object_reward + pose_reward + total_reward = total_reward.clamp(-15, 15) + total_reward[info["success"]] = 15 + return total_reward + + def compute_normalized_dense_reward(self, obs: Any, action: Array, info: Dict): + self.max_reward = 15 + dense_reward = self.compute_dense_reward(obs=obs, action=action, info=info) + norm_dense_reward = dense_reward / (2 * self.max_reward) + 0.5 + return norm_dense_reward + + +@register_env("TriFingerRotateCubeLevel0-v1", max_episode_steps=250) +class RotateCubeEnvLevel0(RotateCubeEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + difficulty_level=0, + **kwargs, + ) + + +@register_env("TriFingerRotateCubeLevel1-v1", max_episode_steps=250) +class RotateCubeEnvLevel1(RotateCubeEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + difficulty_level=1, + **kwargs, + ) + + +@register_env("TriFingerRotateCubeLevel2-v1", max_episode_steps=250) +class RotateCubeEnvLevel2(RotateCubeEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + difficulty_level=2, + **kwargs, + ) + + +@register_env("TriFingerRotateCubeLevel3-v1", max_episode_steps=250) +class RotateCubeEnvLevel3(RotateCubeEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + difficulty_level=3, + **kwargs, + ) + + +@register_env("TriFingerRotateCubeLevel4-v1", max_episode_steps=250) +class RotateCubeEnvLevel4(RotateCubeEnv): + def __init__(self, *args, **kwargs): + super().__init__( + *args, + robot_init_qpos_noise=0.02, + difficulty_level=4, + **kwargs, + ) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/template.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/template.py new file mode 100644 index 0000000000000000000000000000000000000000..9430efcfd1c8c5afd2d5292b0e5ea9b3738bee01 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/template.py @@ -0,0 +1,205 @@ +""" +Code for a minimal environment/task with just a robot being loaded. We recommend copying this template and modifying as you need. + +At a high-level, ManiSkill tasks can minimally be defined by what agents/actors are +loaded, how agents/actors are randomly initialized during env resets, how goals are randomized and parameterized in observations, and success conditions + +Environment reset is comprised of running two functions, `self._reconfigure` and `self.initialize_episode`, which is auto +run by ManiSkill. As a user, you can override a number of functions that affect reconfiguration and episode initialization. + +Reconfiguration will reset the entire environment scene and allow you to load/swap assets and agents. + +Episode initialization will reset the poses of all actors, articulations, and agents, +in addition to initializing any task relevant data like a goal + +See comments for how to make your own environment and what each required function should do. If followed correctly you can easily build a +task that can simulate on the CPU and be parallelized on the GPU without having to manage GPU memory and parallelization apart from some +code that need to be written in batched mode (e.g. reward, success conditions) + +For a minimal implementation of a simple task, check out +mani_skill /envs/tasks/push_cube.py which is annotated with comments to explain how it is implemented +""" + + +from typing import Any, Dict, Union + +import numpy as np +import sapien +import torch + +from mani_skill.agents.multi_agent import MultiAgent +from mani_skill.agents.robots.fetch.fetch import Fetch +from mani_skill.agents.robots.panda.panda import Panda +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.sensors.camera import CameraConfig +from mani_skill.utils import common, sapien_utils +from mani_skill.utils.building import actors +from mani_skill.utils.registration import register_env +from mani_skill.utils.structs.types import GPUMemoryConfig, SimConfig + + +# register the environment by a unique ID and specify a max time limit. Now once this file is imported you can do gym.make("CustomEnv-v0") +@register_env("CustomEnv-v1", max_episode_steps=200) +class CustomEnv(BaseEnv): + """ + Task Description + ---------------- + Add a task description here + + Randomizations + -------------- + - how is it randomized? + - how is that randomized? + + Success Conditions + ------------------ + - what is done to check if this task is solved? + + Visualization: link to a video/gif of the task being solved + """ + + # here you can define a list of robots that this task is built to support and be solved by. This is so that + # users won't be permitted to use robots not predefined here. If SUPPORTED_ROBOTS is not defined then users can do anything + SUPPORTED_ROBOTS = ["panda", "fetch"] + # if you want to say you support multiple robots you can use SUPPORTED_ROBOTS = [["panda", "panda"], ["panda", "fetch"]] etc. + + # to help with programming, you can assert what type of agents are supported like below, and any shared properties of self.agent + # become available to typecheckers and auto-completion. E.g. Panda and Fetch both share a property called .tcp (tool center point). + agent: Union[Panda, Fetch] + # if you want to do typing for multi-agent setups, use this below and specify what possible tuples of robots are permitted by typing + # this will then populate agent.agents (list of the instantiated agents) with the right typing + # agent: MultiAgent[Union[Tuple[Panda, Panda], Tuple[Panda, Panda, Panda]]] + + # in the __init__ function you can pick a default robot your task should use e.g. the panda robot by setting a default for robot_uids argument + # note that if robot_uids is a list of robot uids, then we treat it as a multi-agent setup and load each robot separately. + def __init__(self, *args, robot_uids="panda", robot_init_qpos_noise=0.02, **kwargs): + self.robot_init_qpos_noise = robot_init_qpos_noise + super().__init__(*args, robot_uids=robot_uids, **kwargs) + + # Specify default simulation/gpu memory configurations. Note that tasks need to tune their GPU memory configurations accordingly + # in order to save memory while also running with no errors. In general you can start with low values and increase them + # depending on the messages that show up when you try to run more environments in parallel. Since this is a python property + # you can also check self.num_envs to dynamically set configurations as well + @property + def _default_sim_config(self): + return SimConfig( + gpu_memory_config=GPUMemoryConfig( + found_lost_pairs_capacity=2**25, max_rigid_patch_count=2**18 + ) + ) + + """ + Reconfiguration Code + + below are all functions involved in reconfiguration during environment reset called in the same order. As a user + you can change these however you want for your desired task. These functions will only ever be called once in general. In CPU simulation, + for some tasks these may need to be called multiple times if you need to swap out object assets. In GPU simulation these will only ever be called once. + """ + + def _load_agent(self, options: dict): + # this code loads the agent into the current scene. You should use it to specify the initial pose(s) of the agent(s) + # such that they don't collide with other objects initially + super()._load_agent(options, sapien.Pose(p=[0, 0, 0])) + + def _load_scene(self, options: dict): + # here you add various objects like actors and articulations. If your task was to push a ball, you may add a dynamic sphere object on the ground + pass + + @property + def _default_sensor_configs(self): + # To customize the sensors that capture images/pointclouds for the environment observations, + # simply define a CameraConfig as done below for Camera sensors. You can add multiple sensors by returning a list + pose = sapien_utils.look_at( + eye=[0.3, 0, 0.6], target=[-0.1, 0, 0.1] + ) # sapien_utils.look_at is a utility to get the pose of a camera that looks at a target + + # to see what all the sensors capture in the environment for observations, run env.render_sensors() which returns an rgb array you can visualize + return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)] + + @property + def _default_human_render_camera_configs(self): + # this is just like _sensor_configs, but for adding cameras used for rendering when you call env.render() + # when render_mode="rgb_array" or env.render_rgb_array() + # Another feature here is that if there is a camera called render_camera, this is the default view shown initially when a GUI is opened + pose = sapien_utils.look_at([0.6, 0.7, 0.6], [0.0, 0.0, 0.35]) + return [CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)] + + def _setup_sensors(self, options: dict): + # default code here will setup all sensors. You can add additional code to change the sensors e.g. + # if you want to randomize camera positions + return super()._setup_sensors() + + def _load_lighting(self, options: dict): + # default code here will setup all lighting. You can add additional code to change the lighting e.g. + # if you want to randomize lighting in the scene + return super()._load_lighting() + + """ + Episode Initialization Code + + below are all functions involved in episode initialization during environment reset called in the same order. As a user + you can change these however you want for your desired task. Note that these functions are given a env_idx variable. + + `env_idx` is a torch Tensor representing the indices of the parallel environments that are being initialized/reset. This is used + to support partial resets where some parallel envs might be reset while others are still running (useful for faster RL and evaluation). + Generally you only need to really use it to determine batch sizes via len(env_idx). ManiSkill helps handle internally a lot of masking + you might normally need to do when working with GPU simulation. For specific details check out the push_cube.py code + """ + + def _initialize_episode(self, env_idx: torch.Tensor, options: dict): + pass + + """ + Modifying observations, goal parameterization, and success conditions for your task + + the code below all impact some part of `self.step` function + """ + + def evaluate(self, obs: Any): + # this function is used primarily to determine success and failure of a task, both of which are optional. If a dictionary is returned + # containing "success": bool array indicating if the env is in success state or not, that is used as the terminated variable returned by + # self.step. Likewise if it contains "fail": bool array indicating the opposite (failure state or not) the same occurs. If both are given + # then a logical OR is taken so terminated = success | fail. If neither are given, terminated is always all False. + # + # You may also include additional keys which will populate the info object returned by self.step and that will be given to + # `_get_obs_extra` and `_compute_dense_reward`. Note that as everything is batched, you must return a batched array of + # `self.num_envs` booleans (or 0/1 values) for success an dfail as done in the example below + return { + "success": torch.zeros(self.num_envs, device=self.device, dtype=bool), + "fail": torch.zeros(self.num_envs, device=self.device, dtype=bool), + } + + def _get_obs_extra(self, info: Dict): + # should return an dict of additional observation data for your tasks + # this will be included as part of the observation in the "extra" key when obs_mode="state_dict" or any of the visual obs_modes + # and included as part of a flattened observation when obs_mode="state". Moreover, you have access to the info object + # which is generated by the `evaluate` function above + return dict() + + def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict): + # you can optionally provide a dense reward function by returning a scalar value here. This is used when reward_mode="dense" + # note that as everything is batched, you must return a batch of of self.num_envs rewards as done in the example below. + # Moreover, you have access to the info object which is generated by the `evaluate` function above + return torch.zeros(self.num_envs, device=self.device) + + def compute_normalized_dense_reward( + self, obs: Any, action: torch.Tensor, info: Dict + ): + # this should be equal to compute_dense_reward / max possible reward + max_reward = 1.0 + return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward + + def get_state_dict(self): + # this function is important in order to allow accurate replaying of trajectories. Make sure to specify any + # non simulation state related data such as a random 3D goal position you generated + # alternatively you can skip this part if the environment's rewards, observations, eval etc. are dependent on simulation data only + # e.g. self.your_custom_actor.pose.p will always give you your actor's 3D position + state = super().get_state_dict() + # state["goal_pos"] = add_your_non_sim_state_data_here + return state + + def set_state_dict(self, state): + # this function complements get_state and sets any non simulation state related data correctly so the environment behaves + # the exact same in terms of output rewards, observations, success etc. should you reset state to a given state and take the same actions + self.goal_pos = state["goal_pos"] + super().set_state_dict(state) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/bowl_on_rack.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/bowl_on_rack.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e2fc179c0fee16609c80c35a64b49a80e593e4c Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/bowl_on_rack.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/grasp_bowl_v0.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/grasp_bowl_v0.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..328888fee53e96428bdd63ce9ab909efe97fb7a1 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/grasp_bowl_v0.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/pull_cube_tool.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/pull_cube_tool.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..178ae3389b0554c8c04d47b8bff410a083de31d7 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/pull_cube_tool.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/stack_mug_on_rack.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/stack_mug_on_rack.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a8b2ca13370a08ef243c927f4367bf1bfa48296 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/examples/motionplanning/panda/solutions/__pycache__/stack_mug_on_rack.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/assets/data.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/assets/data.py new file mode 100644 index 0000000000000000000000000000000000000000..41a4f80fc5c2ae0073b1af564f5f8b1d5890e8a9 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/assets/data.py @@ -0,0 +1,216 @@ +""" +Asset sources and tooling for managing the assets +""" + +import os +from dataclasses import dataclass +from typing import Dict, List, Optional + +from mani_skill import ASSET_DIR, PACKAGE_ASSET_DIR +from mani_skill.utils import io_utils + + +@dataclass +class DataSource: + source_type: str + """what kind of data is this""" + url: Optional[str] = None + hf_repo_id: Optional[str] = None + github_url: Optional[str] = None + target_path: Optional[str] = None + """the folder where the file will be downloaded to""" + checksum: Optional[str] = None + zip_dirname: Optional[str] = None + """what to rename a zip files generated directory to""" + filename: Optional[str] = None + """name to change the downloaded file to. If None, will not change the name""" + output_dir: str = ASSET_DIR + + +DATA_SOURCES: Dict[str, DataSource] = {} +"""Data sources map data source IDs to their respective DataSource objects which contain info on what the data is and where to download it""" +DATA_GROUPS: Dict[str, List[str]] = {} +"""Data groups map group ids (typically environment IDs) to a list of data source/group IDs for easy group management. data groups can be done hierarchicaly""" + + +def is_data_source_downloaded(data_source_id: str): + data_source = DATA_SOURCES[data_source_id] + return os.path.exists(data_source.output_dir / data_source.target_path) + + +def initialize_data_sources(): + DATA_SOURCES["ycb"] = DataSource( + source_type="task_assets", + url="https://huggingface.co/datasets/haosulab/ManiSkill2/resolve/main/data/mani_skill2_ycb.zip", + target_path="assets/mani_skill2_ycb", + checksum="eb6f30642c90203715c178f67bf2288887ef6e7d05a9f3f1e713efcf7c2a541c", + ) + DATA_SOURCES["pick_clutter_ycb_configs"] = DataSource( + source_type="task_assets", + url="https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/pick_clutter/ycb_train_5k.json.gz", + target_path="tasks/pick_clutter", + checksum="70ec176c7036f326ea7813b77f8c03bea9db5960198498957a49b2895a9ec338", + ) + DATA_SOURCES["assembling_kits"] = DataSource( + source_type="task_assets", + url="https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/assembling_kits_v1.zip", + target_path="tasks/assembling_kits", + checksum="e3371f17a07a012edaa3a0b3604fb1577f3fb921876c3d5ed59733dd75a6b4a0", + ) + DATA_SOURCES["panda_avoid_obstacles"] = DataSource( + source_type="task_assets", + url="https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/avoid_obstacles/panda_train_2k.json.gz", + target_path="tasks/avoid_obstacles", + checksum="44dae9a0804172515c290c1f49a1e7e72d76e40201a2c5c7d4a3ccd43b4d5be4", + ) + + DATA_SOURCES["bridge_v2_real2sim"] = DataSource( + source_type="task_assets", + url="https://huggingface.co/datasets/haosulab/ManiSkill_bridge_v2_real2sim/resolve/main/bridge_v2_real2sim_dataset.zip", + target_path="tasks/bridge_v2_real2sim_dataset", + checksum="618512a205b4528cafecdad14b1788ed1130879f3064deb406516ed5b9c5ba92", + ) + + # ---------------------------------------------------------------------------- # + # PartNet-mobility + # ---------------------------------------------------------------------------- # + category_uids = {} + for category in ["cabinet_drawer", "cabinet_door", "chair", "bucket", "faucet"]: + model_json = ( + PACKAGE_ASSET_DIR / f"partnet_mobility/meta/info_{category}_train.json" + ) + model_ids = set(io_utils.load_json(model_json).keys()) + category_uids[category] = [] + for model_id in model_ids: + uid = f"partnet_mobility/{model_id}" + DATA_SOURCES[uid] = DataSource( + source_type="objects", + url=f"https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/partnet_mobility/dataset/{model_id}.zip", + target_path=ASSET_DIR / "partnet_mobility" / "dataset" / model_id, + ) + category_uids[category].append(uid) + + DATA_GROUPS["partnet_mobility_cabinet"] = set( + category_uids["cabinet_drawer"] + category_uids["cabinet_door"] + ) + DATA_GROUPS["partnet_mobility_chair"] = category_uids["chair"] + DATA_GROUPS["partnet_mobility_bucket"] = category_uids["bucket"] + DATA_GROUPS["partnet_mobility_faucet"] = category_uids["faucet"] + DATA_GROUPS["partnet_mobility"] = set( + category_uids["cabinet_drawer"] + + category_uids["cabinet_door"] + + category_uids["chair"] + + category_uids["bucket"] + + category_uids["faucet"] + ) + + # DATA_GROUPS["OpenCabinetDrawer-v1"] = category_uids["cabinet_drawer"] + # DATA_GROUPS["OpenCabinetDoor-v1"] = category_uids["cabinet_door"] + # DATA_GROUPS["PushChair-v1"] = category_uids["chair"] + # DATA_GROUPS["MoveBucket-v1"] = category_uids["bucket"] + # DATA_GROUPS["TurnFaucet-v1"] = category_uids["faucet"] + + # ---------------------------------------------------------------------------- # + # Interactable Scene Datasets + # ---------------------------------------------------------------------------- # + DATA_SOURCES["ReplicaCAD"] = DataSource( + source_type="scene", + hf_repo_id="haosulab/ReplicaCAD", + target_path="scene_datasets/replica_cad_dataset", + ) + + DATA_SOURCES["ReplicaCADRearrange"] = DataSource( + source_type="scene", + url="https://huggingface.co/datasets/haosulab/ReplicaCADRearrange/resolve/main/rearrange.zip", + target_path="scene_datasets/replica_cad_dataset/rearrange", + ) + + DATA_SOURCES["AI2THOR"] = DataSource( + source_type="scene", + url="https://huggingface.co/datasets/haosulab/AI2THOR/resolve/main/ai2thor.zip", + target_path="scene_datasets/ai2thor", + ) + + DATA_SOURCES["RoboCasa"] = DataSource( + source_type="scene", + url="https://huggingface.co/datasets/haosulab/RoboCasa/resolve/main/robocasa_dataset.zip", + target_path="scene_datasets/robocasa_dataset", + ) + + # Robots + DATA_SOURCES["xmate3_robotiq"] = DataSource( + source_type="robot", + url="https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/xmate3_robotiq.zip", + target_path="robots/xmate3_robotiq", + checksum="ddda102a20eb41e28a0a501702e240e5d7f4084221a44f580e729f08b7c12d1a", + ) + DATA_SOURCES["ur10e"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-UR10e/archive/refs/tags/v0.1.0.zip", + target_path="robots/ur10e", + ) + DATA_SOURCES["anymal_c"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-ANYmalC/archive/refs/tags/v0.1.1.zip", + target_path="robots/anymal_c", + ) + DATA_SOURCES["unitree_h1"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-UnitreeH1/archive/refs/tags/v0.1.0.zip", + target_path="robots/unitree_h1", + ) + DATA_SOURCES["unitree_g1"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-UnitreeG1/archive/refs/tags/v0.1.0.zip", + target_path="robots/unitree_g1", + ) + DATA_SOURCES["unitree_go2"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-UnitreeGo2/archive/refs/tags/v0.1.1.zip", + target_path="robots/unitree_go2", + ) + DATA_SOURCES["stompy"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-Stompy/archive/refs/tags/v0.1.0.zip", + target_path="robots/stompy", + ) + DATA_SOURCES["widowx250s"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-WidowX250S/archive/refs/tags/v0.2.0.zip", + target_path="robots/widowx", + ) + DATA_SOURCES["googlerobot"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-GoogleRobot/archive/refs/tags/v0.1.0.zip", + target_path="robots/googlerobot", + ) + DATA_SOURCES["robotiq_2f"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-Robotiq_2F/archive/refs/tags/v0.1.0.zip", + target_path="robots/robotiq_2f", + ) + DATA_SOURCES["xarm6"] = DataSource( + source_type="robot", + url="https://github.com/haosulab/ManiSkill-XArm6/archive/refs/tags/v0.1.0.zip", + target_path="robots/xarm6", + ) + + +def expand_data_group_into_individual_data_source_ids(data_group_id: str): + """Expand a data group into a list of individual data source IDs""" + uids = [] + + def helper(uid): + nonlocal uids + if uid in DATA_SOURCES: + uids.append(uid) + elif uid in DATA_GROUPS: + [helper(x) for x in DATA_GROUPS[uid]] + + for uid in DATA_GROUPS[data_group_id]: + helper(uid) + uids = list(set(uids)) + return uids + + +initialize_data_sources() diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/_mjcf_loader.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/_mjcf_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..d735899f7c673e0696324cbca5ad576e6fb20ad0 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/_mjcf_loader.py @@ -0,0 +1,921 @@ +""" +Loader code to import MJCF xml files into SAPIEN + +Code partially adapted from https://github.com/NVIDIA/warp/blob/3ed2ceab824b65486c5204d2a7381d37b79fc314/warp/sim/import_mjcf.py + +Articulations are known as kinematic trees (defined by tags) in Mujoco. A single .xml file can have multiple articulations + +Any tag in but not a tag will be built as separate static actors if possible. Actors that are not static seem to be defined +with a free joint under a single body tag. + +Warnings of unloadable tags/data can be printed if verbosity is turned on (by default it is off) + +Notes: + Joint properties relating to the solver, stiffness, actuator, are all not directly imported here + and instead must be implemented via a controller like other robots in SAPIEN + + Contact tags are not supported + + Tendons/equality constraints are supported but may not work the same + + The default group of geoms is 0 in mujoco. From docs it appears only group 0 and 2 are rendered by default. + This is also by default what the visualizer shows and presumably what image renders show. + Any other group is treated as being invisible (e.g. in SAPIEN we do not add visual bodies). SAPIEN does not currently support + toggling render groups like Mujoco. Sometimes a MJCF might not follow this and will try and render other groups. In that case the loader supports + indicating which other groups to add visual bodies for. + + Ref: https://mujoco.readthedocs.io/en/stable/XMLreference.html#body-geom-group, + https://mujoco.readthedocs.io/en/latest/modeling.html#composite-objects (says group 3 is turned off) + + If contype is 0, it means that geom can't collide with anything. We do this by not adding a collision shape at all. + + geoms under worldbody but not body tags are treated as static objects at the moment. + + Useful references: + - Collision detection: https://mujoco.readthedocs.io/en/stable/computation/index.html#collision-detection + + +""" +import math +import os +import re +import xml.etree.ElementTree as ET +from collections import defaultdict +from copy import deepcopy +from dataclasses import dataclass +from functools import reduce +from typing import Any, Dict, List, Literal, Tuple, Union +from xml.etree.ElementTree import Element + +import numpy as np +import sapien +from sapien import ActorBuilder, Pose +from sapien.physx import PhysxArticulation, PhysxMaterial +from sapien.render import RenderMaterial, RenderTexture2D +from sapien.wrapper.articulation_builder import ( + ArticulationBuilder, + LinkBuilder, + MimicJointRecord, +) +from transforms3d import euler, quaternions + +from mani_skill import logger + + +@dataclass +class MJCFTexture: + name: str + type: Literal["skybox", "cube", "2d"] + rgb1: list + rgb2: list + file: str + + +DEFAULT_MJCF_OPTIONS = dict(contact=True) + + +WARNED_ONCE = defaultdict(lambda: False) + + +def _parse_int(attrib, key, default): + if key in attrib: + return int(attrib[key]) + else: + return default + + +def _parse_float(attrib, key, default): + if key in attrib: + return float(attrib[key]) + else: + return default + + +def _str_to_float(string: str, delimiter=" "): + res = [float(x) for x in string.split(delimiter)] + if len(res) == 1: + return res[0] + return res + + +def _merge_attrib(default_attrib: dict, incoming_attribs: Union[List[dict], dict]): + def helper_merge(a: dict, b: dict, path=[]): + for key in b: + if key in a: + if isinstance(a[key], dict) and isinstance(b[key], dict): + helper_merge(a[key], b[key], path + [str(key)]) + else: + a[key] = b[key] + else: + a[key] = b[key] + return a + + attrib = deepcopy(default_attrib) + if isinstance(incoming_attribs, dict): + incoming_attribs = [incoming_attribs] + reduce(helper_merge, [attrib] + incoming_attribs) + return attrib + + +def _parse_vec(attrib, key, default): + if key in attrib: + out = np.fromstring(attrib[key], sep=" ", dtype=np.float32) + else: + out = np.array(default, dtype=np.float32) + return out + + +def _parse_orientation(attrib, use_degrees, euler_seq): + if "quat" in attrib: + wxyz = np.fromstring(attrib["quat"], sep=" ") + return wxyz + if "euler" in attrib: + euler_angles = np.fromstring(attrib["euler"], sep=" ") + if use_degrees: + euler_angles *= np.pi / 180 + # TODO (stao): support other axes? + return np.array( + euler.euler2quat(euler_angles[0], -euler_angles[1], euler_angles[2]) + ) + if "axisangle" in attrib: + axisangle = np.fromstring(attrib["axisangle"], sep=" ") + angle = axisangle[3] + if use_degrees: + angle *= np.pi / 180 + axis = axisangle[:3] / np.linalg.norm(axisangle[:3]) + return quaternions.axangle2quat(axis, angle) + if "xyaxes" in attrib: + xyaxes = np.fromstring(attrib["xyaxes"], sep=" ") + xaxis = xyaxes[:3] / np.linalg.norm(xyaxes[:3]) + zaxis = xyaxes[3:] / np.linalg.norm(xyaxes[:3]) + yaxis = np.cross(zaxis, xaxis) + yaxis = yaxis / np.linalg.norm(yaxis) + rot_matrix = np.array([xaxis, yaxis, zaxis]).T + return quaternions.mat2quat(rot_matrix) + if "zaxis" in attrib: + zaxis = np.fromstring(attrib["zaxis"], sep=" ") + zaxis = zaxis / np.linalg.norm(zaxis) + xaxis = np.cross(np.array([0, 0, 1]), zaxis) + xaxis = xaxis / np.linalg.norm(xaxis) + yaxis = np.cross(zaxis, xaxis) + yaxis = yaxis / np.linalg.norm(yaxis) + rot_matrix = np.array([xaxis, yaxis, zaxis]).T + return quaternions.mat2quat(rot_matrix) + return np.array([1, 0, 0, 0]) + + +class MJCFLoader: + """ + Class to load MJCF into SAPIEN. + """ + + def __init__(self, ignore_classes=["motor"], visual_groups=[0, 2]): + self.fix_root_link = True + """whether to fix the root link. Note regardless of given XML, the root link is a dummy link this loader + creates which makes a number of operations down the line easier. In general this should be False if there is a freejoint for the root body + of articulations in the XML and should be true if there are no free joints. At the moment when modelling a robot from Mujoco this + must be handled on a case by case basis""" + + self.load_multiple_collisions_from_file = False + self.load_nonconvex_collisions = False + self.multiple_collisions_decomposition = "none" + self.multiple_collisions_decomposition_params = dict() + + self.revolute_unwrapped = False + self.scale = 1.0 + + self.visual_groups = visual_groups + + self.scene: sapien.Scene = None + + self.ignore_classes = ignore_classes + + # self._material = None + # self._patch_radius = 0 + # self._min_patch_radius = 0 + self.density = 1000 + # self._link_material = dict() + # self._link_patch_radius = dict() + # self._link_min_patch_radius = dict() + # self._link_density = dict() + + self._defaults: Dict[str, Element] = dict() + self._assets = dict() + self._materials = dict() + self._textures: Dict[str, MJCFTexture] = dict() + self._meshes: Dict[str, Element] = dict() + + self._link2builder: Dict[str, LinkBuilder] = dict() + self._link2parent_joint: Dict[str, Any] = dict() + self._group_count = 0 + + def set_scene(self, scene): + self.scene = scene + return self + + @staticmethod + def _pose_from_origin(origin, scale): + origin[:3, 3] = origin[:3, 3] * scale + return Pose(origin) + + def _build_geom( + self, geom: Element, builder: Union[LinkBuilder, ActorBuilder], defaults + ): + geom_defaults = defaults + if "class" in geom.attrib: + geom_class = geom.attrib["class"] + ignore_geom = False + for pattern in self.ignore_classes: + if re.match(pattern, geom_class): + ignore_geom = True + break + if ignore_geom: + return + if geom_class in self._defaults: + geom_defaults = _merge_attrib(defaults, self._defaults[geom_class]) + if "geom" in geom_defaults: + geom_attrib = _merge_attrib(geom_defaults["geom"], geom.attrib) + else: + geom_attrib = geom.attrib + + geom_name = geom_attrib.get("name", "") + geom_type = geom_attrib.get("type", "sphere") + if "mesh" in geom_attrib: + geom_type = "mesh" + geom_size = ( + _parse_vec(geom_attrib, "size", np.array([1.0, 1.0, 1.0])) * self.scale + ) + geom_pos = ( + _parse_vec(geom_attrib, "pos", np.array([0.0, 0.0, 0.0])) * self.scale + ) + geom_rot = _parse_orientation(geom_attrib, self._use_degrees, self._euler_seq) + _parse_float(geom_attrib, "density", self.density) + if "material" in geom_attrib: + render_material = self._materials[geom_attrib["material"]] + else: + # use RGBA + render_material = RenderMaterial( + base_color=_parse_vec(geom_attrib, "rgba", [0.5, 0.5, 0.5, 1]) + ) + + geom_density = _parse_float(geom_attrib, "density", 1000.0) + + # if condim is 1, we can easily model the material's friction + condim = _parse_int(geom_attrib, "condim", 3) + if condim == 3: + friction = _parse_vec( + geom_attrib, "friction", np.array([0.3, 0.3, 0.3]) + ) # maniskill default friction is 0.3 + # NOTE (stao): we only support sliding friction at the moment. see + # https://mujoco.readthedocs.io/en/stable/XMLreference.html#body-geom-friction + # we might be able to imitate their torsional frictions via patch radius attributes: + # https://nvidia-omniverse.github.io/PhysX/physx/5.4.0/_api_build/class_px_shape.html#_CPPv4N7PxShape23setTorsionalPatchRadiusE6PxReal + friction = friction[0] + physx_material = PhysxMaterial( + static_friction=friction, dynamic_friction=friction, restitution=0 + ) + elif condim == 1: + physx_material = PhysxMaterial( + static_friction=0, dynamic_friction=0, restitution=0 + ) + else: + physx_material = None + + geom_group = _parse_int(geom_attrib, "group", 0) + # See note at top of file for how we handle geom groups + has_visual_body = False + if geom_group in self.visual_groups: + has_visual_body = True + + geom_contype = _parse_int(geom_attrib, "contype", 1) + # See note at top of file for how we handle contype / objects without collisions + has_collisions = True + if geom_contype == 0: + has_collisions = False + + t_visual2link = Pose(geom_pos, geom_rot) + if geom_type == "sphere": + if has_visual_body: + builder.add_sphere_visual( + t_visual2link, radius=geom_size[0], material=render_material + ) + if has_collisions: + builder.add_sphere_collision( + t_visual2link, + radius=geom_size[0], + material=physx_material, + density=geom_density, + ) + elif geom_type in ["capsule", "cylinder", "box"]: + if "fromto" in geom_attrib: + geom_fromto = _parse_vec( + geom_attrib, "fromto", (0.0, 0.0, 0.0, 1.0, 0.0, 0.0) + ) + + start = np.array(geom_fromto[0:3]) * self.scale + end = np.array(geom_fromto[3:6]) * self.scale + # objects follow a line from start to end. + + # objects are default along x-axis and we rotate accordingly via axis angle. + axis = (end - start) / np.linalg.norm(end - start) + # TODO this is bugged + angle = math.acos(np.dot(axis, np.array([1.0, 0.0, 0.0]))) + axis = np.cross(axis, np.array([1.0, 0.0, 0.0])) + if np.linalg.norm(axis) < 1e-3: + axis = np.array([1, 0, 0]) + else: + axis = axis / np.linalg.norm(axis) + + geom_pos = (start + end) * 0.5 + geom_rot = quaternions.axangle2quat(axis, -angle) + t_visual2link.set_p(geom_pos) + t_visual2link.set_q(geom_rot) + geom_radius = geom_size[0] + geom_half_length = np.linalg.norm(end - start) * 0.5 + else: + geom_radius = geom_size[0] + geom_half_length = geom_size[1] + # TODO (stao): oriented along z-axis for capsules whereas boxes are not? + if geom_type in ["capsule", "cylinder"]: + t_visual2link = t_visual2link * Pose( + q=euler.euler2quat(0, np.pi / 2, 0) + ) + if geom_type == "capsule": + if has_visual_body: + builder.add_capsule_visual( + t_visual2link, + radius=geom_radius, + half_length=geom_half_length, + material=render_material, + name=geom_name, + ) + if has_collisions: + builder.add_capsule_collision( + t_visual2link, + radius=geom_radius, + half_length=geom_half_length, + material=physx_material, + density=geom_density, + # name=geom_name, + ) + elif geom_type == "box": + if has_visual_body: + builder.add_box_visual( + t_visual2link, + half_size=geom_size, + material=render_material, + name=geom_name, + ) + if has_collisions: + builder.add_box_collision( + t_visual2link, + half_size=geom_size, + material=physx_material, + density=geom_density, + # name=geom_name, + ) + elif geom_type == "cylinder": + if has_visual_body: + builder.add_cylinder_visual( + t_visual2link, + radius=geom_radius, + half_length=geom_half_length, + material=render_material, + name=geom_name, + ) + if has_collisions: + builder.add_cylinder_collision( + t_visual2link, + radius=geom_radius, + half_length=geom_half_length, + material=physx_material, + density=geom_density, + # name=geom_name + ) + + elif geom_type == "plane": + if not WARNED_ONCE["plane"]: + logger.warn( + "Currently ManiSkill does not support loading plane geometries from MJCFs" + ) + WARNED_ONCE["plane"] = True + elif geom_type == "ellipsoid": + if not WARNED_ONCE["ellipsoid"]: + logger.warn( + "Currently ManiSkill does not support loading ellipsoid geometries from MJCFs" + ) + WARNED_ONCE["ellipsoid"] = True + elif geom_type == "mesh": + mesh_name = geom_attrib.get("mesh") + mesh_attrib = self._meshes[mesh_name].attrib + mesh_scale = self.scale * np.array( + _parse_vec(mesh_attrib, "scale", np.array([1, 1, 1])) + ) + # TODO refquat + mesh_file = os.path.join(self._mesh_dir, mesh_attrib["file"]) + if has_visual_body: + builder.add_visual_from_file( + mesh_file, + pose=t_visual2link, + scale=mesh_scale, + material=render_material, + ) + if has_collisions: + if self.load_multiple_collisions_from_file: + builder.add_multiple_convex_collisions_from_file( + mesh_file, + pose=t_visual2link, + scale=mesh_scale, + material=physx_material, + density=geom_density, + ) + else: + builder.add_convex_collision_from_file( + mesh_file, + pose=t_visual2link, + scale=mesh_scale, + material=physx_material, + density=geom_density, + ) + elif geom_type == "sdf": + raise NotImplementedError("SDF geom type not supported at the moment") + elif geom_type == "hfield": + raise NotImplementedError("Height fields are not supported at the moment") + + def _build_link( + self, body: Element, body_attrib, link_builder: LinkBuilder, defaults + ): + """sets inertial, visual/collision shapes""" + # inertial + # TODO (stao) + # if ( + # link.inertial + # and link.inertial.mass != 0 + # and not np.array_equal(link.inertial.inertia, np.zeros((3, 3))) + # ): + # t_inertial2link = self._pose_from_origin(link.inertial.origin, self.scale) + # mass = link.inertial.mass + # inertia = link.inertial.inertia + + # if np.array_equal(np.diag(np.diag(inertia)), inertia): + # eigs = np.diag(inertia) + # vecs = np.eye(3) + # else: + # eigs, vecs = np.linalg.eigh(inertia) + # if np.linalg.det(vecs) < 0: + # vecs[:, 2] = -vecs[:, 2] + + # assert all([x > 0 for x in eigs]), "invalid moment of inertia" + + # t_inertia2inertial = np.eye(4) + # t_inertia2inertial[:3, :3] = vecs + # t_inertia2inertial = Pose(t_inertia2inertial) + + # t_inertial2link = t_inertial2link * t_inertia2inertial + # scale3 = self.scale**3 + # scale5 = self.scale**5 + # link_builder.set_mass_and_inertia( + # mass * scale3, t_inertial2link, scale5 * eigs + # ) + + # go through each geometry of the body + for geo_count, geom in enumerate(body.findall("geom")): + self._build_geom(geom, link_builder, defaults) + + def _parse_texture(self, texture: Element): + """Parse MJCF textures to then be referenced by materials: https://mujoco.readthedocs.io/en/stable/XMLreference.html#asset-texture + + NOTE: + - Procedural texture generation is currently not supported. + - Different texture types are not really supported + """ + name = texture.get("name") + file = texture.get("file") + self._textures[name] = MJCFTexture( + name=name, + type=texture.get("type"), + rgb1=texture.get("rgb1"), + rgb2=texture.get("rgb2"), + file=os.path.join(self._mesh_dir, file) if file else None, + ) + + def _parse_material(self, material: Element): + """Parse MJCF materials in asset to sapien render materials""" + name = material.get("name") + texture = None + if material.get("texture") in self._textures: + texture = self._textures[material.get("texture")] + + # NOTE: Procedural texture generation is currently not supported. + # Defaults from https://mujoco.readthedocs.io/en/stable/XMLreference.html#asset-material + em_val = _parse_float(material.attrib, "emission", 0) + rgba = np.array(_parse_vec(material.attrib, "rgba", [1, 1, 1, 1])) + render_material = RenderMaterial( + emission=[rgba[0] * em_val, rgba[1] * em_val, rgba[2] * em_val, 1], + base_color=rgba, + specular=_parse_float(material.attrib, "specular", 0), + # TODO (stao): double check below 2 properties are right + roughness=1 - _parse_float(material.attrib, "reflectance", 0), + metallic=_parse_float(material.attrib, "shininess", 0.5), + ) + if texture is not None and texture.file is not None: + render_material.base_color_texture = RenderTexture2D(filename=texture.file) + self._materials[name] = render_material + + def _parse_mesh(self, mesh: Element): + """Parse MJCF mesh data in asset""" + # Vertex, normal, texcoord are not supported, file is required + file = mesh.get("file") + assert ( + file is not None + ), "Mesh file not provided. While Mujoco allows file to be optional, for loading into SAPIEN this is not optional" + name = mesh.get("name", os.path.splitext(file)[0]) + self._meshes[name] = mesh + + @property + def _root_default(self): + if "__root__" not in self._defaults: + return {} + return self._defaults["__root__"] + + def _parse_default(self, node: Element, parent: Element): + """Parse a MJCF default attribute. https://mujoco.readthedocs.io/en/stable/modeling.html#default-settings explains how it works""" + class_name = "__root__" + if node.tag == "default": + if "class" in node.attrib: + class_name = node.attrib["class"] + if parent is not None and "class" in parent.attrib: + self._defaults[class_name] = deepcopy( + self._defaults[parent.attrib["class"]] + ) + else: + self._defaults[class_name] = {} + for child in node: + if child.tag == "default": + self._parse_default(child, node) + else: + if child.tag in self._defaults[class_name]: + self._defaults[class_name][child.tag] = _merge_attrib( + self._defaults[class_name][child.tag], child.attrib + ) + else: + self._defaults[class_name][child.tag] = child.attrib + + def _parse_body( + self, + body: Element, + parent: LinkBuilder, + incoming_defaults: dict, + builder: ArticulationBuilder, + ): + body_class = body.get("childclass") + if body_class is None: + defaults = incoming_defaults + else: + for pattern in self.ignore_classes: + if re.match(pattern, body_class): + return + defaults = _merge_attrib(incoming_defaults, self._defaults[body_class]) + + if "body" in defaults: + body_attrib = _merge_attrib(defaults["body"], body.attrib) + else: + body_attrib = body.attrib + + body_name = body_attrib["name"] + body_pos = _parse_vec(body_attrib, "pos", (0.0, 0.0, 0.0)) + body_ori = _parse_orientation( + body_attrib, use_degrees=self._use_degrees, euler_seq=self._euler_seq + ) + + body_pos *= self.scale + body_pose = Pose(body_pos, q=body_ori) + + link_builder = parent + + joints = body.findall("joint") + # if body has no joints, it is a fixed joint + if len(joints) == 0: + joints = [ET.Element("joint", attrib=dict(type="fixed"))] + for i, joint in enumerate(joints): + # note there can be multiple joints here. We create some dummy links to simulate that + incoming_attributes = [] + if "joint" in defaults: + incoming_attributes.append(defaults["joint"]) + if "class" in joint.attrib: + incoming_attributes.append( + self._defaults[joint.attrib["class"]]["joint"] + ) + incoming_attributes.append(joint.attrib) + joint_attrib = _merge_attrib(dict(), incoming_attributes) + + # build the link + link_builder = builder.create_link_builder(parent=link_builder) + link_builder.set_joint_name(joint_attrib.get("name", "")) + if i == len(joints) - 1: + link_builder.set_name(f"{body_name}") + # the last link is the "real" one, the rest are dummy links to support multiple joints acting on a link + self._build_link(body, body_attrib, link_builder, defaults) + else: + link_builder.set_name(f"{body_name}_dummy_{i}") + self._link2builder[link_builder.name] = link_builder + + joint_type = joint_attrib.get("type", "hinge") + joint_pos = np.array(_parse_vec(joint_attrib, "pos", [0, 0, 0])) + t_joint2parent = Pose() + if i == 0: + t_joint2parent = body_pose + + friction = _parse_float(joint_attrib, "frictionloss", 0) + damping = _parse_float(joint_attrib, "damping", 0) + + # compute joint axis and relative transformations + axis = _parse_vec(joint_attrib, "axis", [0.0, 0.0, 0.0]) + axis_norm = np.linalg.norm(axis) + if axis_norm < 1e-3: + axis = np.array([1.0, 0.0, 0.0]) + else: + axis /= axis_norm + + if abs(axis @ [1.0, 0.0, 0.0]) > 0.9: + axis1 = np.cross(axis, [0.0, 0.0, 1.0]) + axis1 /= np.linalg.norm(axis1) + else: + axis1 = np.cross(axis, [1.0, 0.0, 0.0]) + axis1 /= np.linalg.norm(axis1) + axis2 = np.cross(axis, axis1) + t_axis2joint = np.eye(4) + t_axis2joint[:3, 3] = joint_pos + t_axis2joint[:3, 0] = axis + t_axis2joint[:3, 1] = axis1 + t_axis2joint[:3, 2] = axis2 + t_axis2joint = Pose(t_axis2joint) + t_axis2parent = t_joint2parent * t_axis2joint + + limited = joint_attrib.get("limited", "auto") + if limited == "auto": + if "range" in joint_attrib: + limited = True + else: + limited = False + elif limited == "true": + limited = True + else: + limited = False + + # set the joint properties to create it + if joint_type == "hinge": + if limited: + joint_limits = _parse_vec(joint_attrib, "range", [0, 0]) + if self._use_degrees: + joint_limits = np.deg2rad(joint_limits) + link_builder.set_joint_properties( + "revolute_unwrapped", + [joint_limits], + t_axis2parent, + t_axis2joint, + friction, + damping, + ) + else: + link_builder.set_joint_properties( + "revolute", + [[-np.inf, np.inf]], + t_axis2parent, + t_axis2joint, + friction, + damping, + ) + elif joint_type == "slide": + if limited: + limits = [_parse_vec(joint_attrib, "range", [0, 0]) * self.scale] + else: + limits = [[-np.inf, np.inf]] + link_builder.set_joint_properties( + "prismatic", + limits, + t_axis2parent, + t_axis2joint, + friction, + damping, + ) + elif joint_type == "fixed": + link_builder.set_joint_properties( + "fixed", + [], + t_axis2parent, + t_axis2joint, + friction, + damping, + ) + + # ensure adjacent links do not collide. Normally SAPIEN does this + # but we often create dummy links to support multiple joints between two link functionality + # that mujoco has so it must be done here. + if parent is not None: + parent.collision_groups[2] |= 1 << (self._group_count) + link_builder.collision_groups[2] |= 1 << (self._group_count) + self._group_count += 1 + + for child in body.findall("body"): + self._parse_body(child, link_builder, defaults, builder) + + def _parse_constraint(self, constraint: Element): + joint_elems = [] + for joint in constraint.findall("joint"): + joint_elems.append(joint) + return MimicJointRecord( + joint_elems[0].attrib["joint"], + joint_elems[1].attrib["joint"], + 1, + 0 + # joint.mimic.multiplier, + # joint.mimic.offset, + ) + + def _parse_mjcf( + self, mjcf_string: str + ) -> Tuple[List[ArticulationBuilder], List[ActorBuilder], None]: + """Helper function for self.parse""" + xml: Element = ET.fromstring(mjcf_string.encode("utf-8")) + self.xml = xml + # handle includes + for include in xml.findall("include"): + include_file = include.attrib["file"] + with open(os.path.join(self.mjcf_dir, include_file), "r") as f: + include_file_str = f.read() + include_xml = ET.fromstring(include_file_str.encode("utf-8")) + for child in include_xml: + xml.append(child) + + self._use_degrees = True # angles are in degrees by default + self._mjcf_options = DEFAULT_MJCF_OPTIONS + self._euler_seq = [1, 2, 3] # XYZ by default + + ### Parse compiler options ### + compiler = xml.find("compiler") + if compiler is not None: + self._use_degrees = ( + compiler.attrib.get("angle", "degree").lower() == "degree" + ) + self._euler_seq = [ + "xyz".index(c) + 1 + for c in compiler.attrib.get("eulerseq", "xyz").lower() + ] + self._mesh_dir = compiler.attrib.get("meshdir", ".") + else: + self._mesh_dir = "." + self._mesh_dir = os.path.join(self.mjcf_dir, self._mesh_dir) + + ### Parse options/flags ### + option = xml.find("option") + if option is not None: + for flag in option.findall("flag"): + update_dict = dict() + for k, v in flag.attrib.items(): + update_dict[k] = True if v == "enable" else False + self._mjcf_options.update(update_dict) + + ### Parse assets ### + for asset in xml.findall("asset"): + for texture in asset.findall("texture"): + self._parse_texture(texture) + for material in asset.findall("material"): + self._parse_material(material) + for mesh in asset.findall("mesh"): + self._parse_mesh(mesh) + + ### Parse defaults ### + for default in xml.findall("default"): + self._parse_default(default, None) + + ### Parse Kinematic Trees / Articulations in World Body ### + + # NOTE (stao): For now we assume there is only one articulation. Some setups like Aloha 2 are technically 2 articulations + # but you can treat it as a single one anyway + articulation_builders: List[ArticulationBuilder] = [] + actor_builders: List[ActorBuilder] = [] + for i, body in enumerate(xml.find("worldbody").findall("body")): + # determine first if this body is really an articulation or a actor + has_freejoint = body.find("freejoint") is not None + + def has_joint(body): + if body.find("joint") is not None: + return True + for child in body.findall("body"): + if has_joint(child): + return True + return False + + is_articulation = has_joint(body) or has_freejoint + # tag refers to an artciulation in physx only if there is another body tag inside it + if is_articulation: + builder = self.scene.create_articulation_builder() + articulation_builders.append(builder) + dummy_root_link = builder.create_link_builder(None) + dummy_root_link.name = f"dummy_root_{i}" + + # Check if the body tag only contains another body tag and nothing else + body_children = list(body) + tag_counts = defaultdict(int) + for child in body_children: + tag_counts[child.tag] += 1 + if ( + tag_counts["body"] == 1 + and "geom" not in tag_counts + and "joint" not in tag_counts + ): + # If so, skip the current body and continue with its child + body = body.find("body") + self._parse_body(body, dummy_root_link, self._root_default, builder) + + # handle free joints + fix_root_link = not has_freejoint + if fix_root_link: + dummy_root_link.set_joint_properties( + type="fixed", + limits=None, + pose_in_parent=Pose(), + pose_in_child=Pose(), + ) + else: + builder = self.scene.create_actor_builder() + body_type = "dynamic" if has_freejoint else "static" + actor_builders.append(builder) + # NOTE that mujoco supports nested body tags to define groups of geoms + cur_body = body + while cur_body is not None: + for i, geom in enumerate(cur_body.findall("geom")): + self._build_geom(geom, builder, self._root_default) + builder.set_name(geom.get("name", "")) + builder.set_physx_body_type(body_type) + cur_body = cur_body.find("body") + + ### Parse geoms in World Body ### + # These can't have freejoints so they can't be dynamic + for i, geom in enumerate(xml.find("worldbody").findall("geom")): + builder = self.scene.create_actor_builder() + actor_builders.append(builder) + self._build_geom(geom, builder, self._root_default) + builder.set_name(geom.get("name", "")) + builder.set_physx_body_type("static") + + ### Parse contact and exclusions ### + for contact in xml.findall("contact"): + # TODO + pass + + ### Parse equality constraints ### + # tendon = xml.find("tendon") + # if tendon is not None: + # # TODO (stao): unclear if this actually works + # for constraint in tendon.findall("fixed"): + # record = self._parse_constraint(constraint) + # builder.mimic_joint_records.append(record) + + if not self._mjcf_options["contact"]: + # means to disable all contacts + for actor in actor_builders: + actor.collision_groups[2] |= 1 << 1 + for art in articulation_builders: + for link in art.link_builders: + link.collision_groups[2] |= 1 << 1 + + return articulation_builders, actor_builders, [] + + def parse(self, mjcf_file: str, package_dir=None): + """Parses a given MJCF file into articulation builders and actor builders and sensor configs""" + self.package_dir = package_dir + self.mjcf_dir = os.path.dirname(mjcf_file) + + with open(mjcf_file, "r") as f: + mjcf_string = f.read() + + return self._parse_mjcf(mjcf_string) + + def load(self, mjcf_file: str, package_dir=None): + """Parses a given mjcf .xml file and builds all articulations and actors""" + articulation_builders, actor_builders, cameras = self.parse( + mjcf_file, package_dir + ) + + articulations: List[PhysxArticulation] = [] + for b in articulation_builders: + articulations.append(b.build()) + + actors = [] + for b in actor_builders: + actors.append(b.build()) + + # TODO (stao): how does mjcf specify sensors? + # name2entity = dict() + # for a in articulations: + # for l in a.links: + # name2entity[l.name] = l.entity + + # for a in actors: + # name2entity[a.name] = a + return articulations[0] + + # TODO (stao): function to also load the scene in? + # TODO (stao): function to load camera configs? diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/actor_builder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/actor_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..fb72f9364704e07578efaafb523ece5049db028d --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/actor_builder.py @@ -0,0 +1,368 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, List, Optional, Sequence, Union + +import numpy as np +import sapien +import sapien.physx as physx +import torch +from sapien import ActorBuilder as SAPIENActorBuilder +from sapien.wrapper.coacd import do_coacd + +from mani_skill import logger +from mani_skill.utils import common +from mani_skill.utils.structs.actor import Actor +from mani_skill.utils.structs.pose import Pose, to_sapien_pose + +if TYPE_CHECKING: + from mani_skill.envs.scene import ManiSkillScene + + +class ActorBuilder(SAPIENActorBuilder): + """ + ActorBuilder class to flexibly build actors in both CPU and GPU simulations. + This directly inherits the original flexible ActorBuilder from sapien and changes the build functions to support a batch of scenes and return a batch of Actors + """ + + scene: ManiSkillScene + + def __init__(self): + super().__init__() + self.initial_pose = None + self.scene_idxs = None + self._allow_overlapping_plane_collisions = False + self._plane_collision_poses = set() + self._procedural_shapes = [] + """procedurally generated shapes to attach""" + + def set_scene_idxs( + self, + scene_idxs: Optional[ + Union[List[int], Sequence[int], torch.Tensor, np.ndarray] + ] = None, + ): + """ + Set a list of scene indices to build this object in. Cannot be used in conjunction with scene mask + """ + self.scene_idxs = scene_idxs + return self + + def set_allow_overlapping_plane_collisions(self, v: bool): + """Set whether or not to permit allowing overlapping plane collisions. In general if you are creating an Actor with a plane collision that is parallelized across multiple + sub-scenes, you only need one of those collision shapes. If you add multiple, it will cause the simulation to slow down significantly. By default this is set to False + """ + self._allow_overlapping_plane_collisions = v + return self + + def build_physx_component(self, link_parent=None): + for r in self.collision_records: + assert isinstance(r.material, physx.PhysxMaterial) + + if self.physx_body_type == "dynamic": + component = physx.PhysxRigidDynamicComponent() + elif self.physx_body_type == "kinematic": + component = physx.PhysxRigidDynamicComponent() + component.kinematic = True + elif self.physx_body_type == "static": + component = physx.PhysxRigidStaticComponent() + elif self.physx_body_type == "link": + component = physx.PhysxArticulationLinkComponent(link_parent) + else: + raise Exception(f"invalid physx body type [{self.physx_body_type}]") + + for r in self.collision_records: + try: + if r.type == "plane": + # skip adding plane collisions if we already added one. + pose_key = (tuple(r.pose.p), tuple(r.pose.q)) + if ( + self._allow_overlapping_plane_collisions + or pose_key not in self._plane_collision_poses + ): + shape = physx.PhysxCollisionShapePlane( + material=r.material, + ) + shapes = [shape] + self._plane_collision_poses.add(pose_key) + else: + continue + elif r.type == "box": + shape = physx.PhysxCollisionShapeBox( + half_size=r.scale, material=r.material + ) + shapes = [shape] + elif r.type == "capsule": + shape = physx.PhysxCollisionShapeCapsule( + radius=r.radius, + half_length=r.length, + material=r.material, + ) + shapes = [shape] + elif r.type == "cylinder": + shape = physx.PhysxCollisionShapeCylinder( + radius=r.radius, + half_length=r.length, + material=r.material, + ) + shapes = [shape] + elif r.type == "sphere": + shape = physx.PhysxCollisionShapeSphere( + radius=r.radius, + material=r.material, + ) + shapes = [shape] + elif r.type == "convex_mesh": + shape = physx.PhysxCollisionShapeConvexMesh( + filename=r.filename, + scale=r.scale, + material=r.material, + ) + shapes = [shape] + elif r.type == "nonconvex_mesh": + shape = physx.PhysxCollisionShapeTriangleMesh( + filename=r.filename, + scale=r.scale, + material=r.material, + ) + shapes = [shape] + elif r.type == "multiple_convex_meshes": + if r.decomposition == "coacd": + params = r.decomposition_params + if params is None: + params = dict() + + filename = do_coacd(r.filename, **params) + else: + filename = r.filename + + shapes = physx.PhysxCollisionShapeConvexMesh.load_multiple( + filename=filename, + scale=r.scale, + material=r.material, + ) + else: + raise RuntimeError(f"invalid collision shape type [{r.type}]") + except RuntimeError: + # ignore runtime error (e.g., failed to cooke mesh) + continue + + for shape in shapes: + shape.local_pose = r.pose + shape.set_collision_groups(self.collision_groups) + shape.set_density(r.density) + shape.set_patch_radius(r.patch_radius) + shape.set_min_patch_radius(r.min_patch_radius) + component.attach(shape) + + if hasattr(self, "_auto_inertial"): + if not self._auto_inertial and self.physx_body_type != "kinematic": + component.mass = self._mass + component.cmass_local_pose = self._cmass_local_pose + component.inertia = self._inertia + + return component + + def build_dynamic(self, name): + self.set_physx_body_type("dynamic") + return self.build(name=name) + + def build_kinematic(self, name): + self.set_physx_body_type("kinematic") + return self.build(name=name) + + def build_static(self, name): + self.set_physx_body_type("static") + return self.build(name=name) + + def build_entity(self): + """ + build the raw sapien entity. Modifies original SAPIEN function to accept new procedurally generated render components + """ + entity = sapien.Entity() + if self.visual_records or len(self._procedural_shapes) > 0: + render_component = self.build_render_component() + for shape in self._procedural_shapes: + render_component.attach(shape) + entity.add_component(render_component) + entity.add_component(self.build_physx_component()) + entity.name = self.name + return entity + + def build(self, name): + """ + Build the actor with the given name. + + Different to the original SAPIEN API, a unique name is required here. + """ + self.set_name(name) + + assert ( + self.name is not None + and self.name != "" + and self.name not in self.scene.actors + ), "built actors in ManiSkill must have unique names and cannot be None or empty strings" + + num_actors = self.scene.num_envs + if self.scene_idxs is not None: + self.scene_idxs = common.to_tensor( + self.scene_idxs, device=self.scene.device + ).to(torch.int) + else: + self.scene_idxs = torch.arange((self.scene.num_envs), dtype=int) + num_actors = len(self.scene_idxs) + + if self.initial_pose is None: + logger.warn( + f"No initial pose set for actor builder of {self.name}, setting to default pose q=[1,0,0,0], p=[0,0,0]. Not setting reasonable initial poses may slow down simulation, see https://github.com/haosulab/ManiSkill/issues/421." + ) + self.initial_pose = Pose.create(sapien.Pose()) + else: + self.initial_pose = Pose.create(self.initial_pose, device=self.scene.device) + + initial_pose_b = self.initial_pose.raw_pose.shape[0] + assert initial_pose_b == 1 or initial_pose_b == num_actors + initial_pose_np = common.to_numpy(self.initial_pose.raw_pose) + if initial_pose_b == 1: + initial_pose_np = initial_pose_np.repeat(num_actors, axis=0) + if self.scene.parallel_in_single_scene: + initial_pose_np[:, :3] += self.scene.scene_offsets_np[ + common.to_numpy(self.scene_idxs) + ] + entities = [] + + for i, scene_idx in enumerate(self.scene_idxs): + if self.scene.parallel_in_single_scene: + sub_scene = self.scene.sub_scenes[0] + else: + sub_scene = self.scene.sub_scenes[scene_idx] + entity = self.build_entity() + # prepend scene idx to entity name to indicate which sub-scene it is in + entity.name = f"scene-{scene_idx}_{self.name}" + # set pose before adding to scene + entity.pose = to_sapien_pose(initial_pose_np[i]) + sub_scene.add_entity(entity) + entities.append(entity) + actor = Actor.create_from_entities(entities, self.scene, self.scene_idxs) + + # if it is a static body type and this is a GPU sim but we are given a single initial pose, we repeat it for the purposes of observations + if ( + self.physx_body_type == "static" + and initial_pose_b == 1 + and self.scene.gpu_sim_enabled + ): + actor.initial_pose = Pose.create( + self.initial_pose.raw_pose.repeat(num_actors, 1) + ) + else: + actor.initial_pose = self.initial_pose + self.scene.actors[self.name] = actor + self.scene.add_to_state_dict_registry(actor) + return actor + + """ + additional procedurally generated visual meshes + """ + + def add_plane_repeated_visual( + self, + pose: sapien.Pose = sapien.Pose(), + half_size: List[float] = [5, 5], + mat: sapien.render.RenderMaterial = None, + texture_repeat: List[float] = [1, 1], + ): + """Procedurally generateds a repeated 2D texture. Works similarly to https://mujoco.readthedocs.io/en/stable/XMLreference.html#asset-material-texrepeat + + currently this always adds a back face + + Args: + texture_repeat: the number of times to repeat the texture in each direction. + """ + floor_width = half_size[0] * 2 + floor_length = half_size[1] * 2 + floor_width = int(np.ceil(floor_width)) + floor_length = int(np.ceil(floor_length)) + + # generate a grid of right triangles that form 1x1 meter squares centered at (0, 0, 0) + # for squares on the edge we cut them off + + # floor_length = floor_width if floor_length is None else floor_length + num_verts = (floor_width + 1) * (floor_length + 1) + vertices = np.zeros((int(num_verts), 3)) + floor_half_width = floor_width / 2 + floor_half_length = floor_length / 2 + xrange = np.arange(start=-floor_half_width, stop=floor_half_width + 1) + yrange = np.arange(start=-floor_half_length, stop=floor_half_length + 1) + xx, yy = np.meshgrid(xrange, yrange) + xys = np.stack((xx, yy), axis=2).reshape(-1, 2) + vertices[:, 0] = xys[:, 0] + vertices[:, 1] = xys[:, 1] + normals = np.zeros((len(vertices), 3)) + normals[:, 2] = -1 + + # the number of times the texture repeats essentially. + uvs = np.zeros((len(vertices), 2)) + # texture_repeat = [1,1] + uvs[:, 0] = xys[:, 0] * texture_repeat[0] + uvs[:, 1] = xys[:, 1] * texture_repeat[1] + + # TODO: This is fast but still two for loops which is a little annoying + triangles = [] + for i in range(floor_length): + triangles.append( + np.stack( + [ + np.arange(floor_width) + i * (floor_width + 1), + np.arange(floor_width) + + 1 + + floor_width + + i * (floor_width + 1), + np.arange(floor_width) + 1 + i * (floor_width + 1), + ], + axis=1, + ) + ) + for i in range(floor_length): + triangles.append( + np.stack( + [ + np.arange(floor_width) + + 1 + + floor_width + + i * (floor_width + 1), + np.arange(floor_width) + + floor_width + + 2 + + i * (floor_width + 1), + np.arange(floor_width) + 1 + i * (floor_width + 1), + ], + axis=1, + ) + ) + triangles = np.concatenate(triangles) + + # vertices: (N, 3) + # triangles: (M, 3) of index triplets referencing vertices + # normals: (N, 3) normals of the vertices. These should all face the same direction + # uvs: (N, 2) uv coordinates for the vertices + if half_size[0] < floor_half_width: + diff = floor_half_width - half_size[0] + for sign in [-1, 1]: + mask = vertices[:, 0] == floor_half_width * sign + vertices[mask, 0] = half_size[0] * sign + uvs[mask, 0] -= 1 * diff * sign * texture_repeat[0] + + if half_size[1] < floor_half_length: + diff = floor_half_length - half_size[1] + for sign in [-1, 1]: + mask = vertices[:, 1] == floor_half_length * sign + vertices[mask, 1] = half_size[1] * sign + uvs[mask, 1] -= diff * sign * texture_repeat[1] + shape = sapien.render.RenderShapeTriangleMesh( + vertices=vertices, + triangles=triangles, + normals=normals, + uvs=uvs, + material=mat, + ) + shape.local_pose = pose + self._procedural_shapes.append(shape) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/ground.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/ground.py new file mode 100644 index 0000000000000000000000000000000000000000..4e500d1e352db83f0a9fe45e190bfd4cac22bd12 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/ground.py @@ -0,0 +1,107 @@ +""" +Useful utilities for creating the ground of a scene +""" + +from __future__ import annotations + +import os.path as osp +from typing import TYPE_CHECKING + +import numpy as np +import sapien +import sapien.render + +if TYPE_CHECKING: + from mani_skill.envs.scene import ManiSkillScene + + +def build_ground( + scene: ManiSkillScene, + floor_width: int = 100, + floor_length: int = None, + xy_origin: tuple = (0, 0), + altitude=0, + name="ground", + texture_file=osp.join(osp.dirname(__file__), "assets/grid_texture.png"), + texture_square_len=4, + mipmap_levels=4, + add_collision=True, +): + """Procedurally creates a checkered floor given a floor width in meters. + + Note that this function runs slower as floor width becomes larger, but in general this function takes no more than 0.05s to run + and usually is never run more than once as it is for building a scene, not loading. + """ + ground = scene.create_actor_builder() + if add_collision: + ground.add_plane_collision( + sapien.Pose(p=[0, 0, altitude], q=[0.7071068, 0, -0.7071068, 0]), + ) + ground.initial_pose = sapien.Pose(p=[0, 0, 0], q=[1, 0, 0, 0]) + if scene.parallel_in_single_scene: + # when building a ground and using a parallel render in the GUI, we want to only build one ground visual+collision plane + ground.set_scene_idxs([0]) + actor = ground.build_static(name=name) + + # generate a grid of right triangles that form 1x1 meter squares centered at (0, 0, 0) + floor_length = floor_width if floor_length is None else floor_length + num_verts = (floor_width + 1) * (floor_length + 1) + vertices = np.zeros((num_verts, 3)) + floor_half_width = floor_width / 2 + floor_half_length = floor_length / 2 + xrange = np.arange(start=-floor_half_width, stop=floor_half_width + 1) + yrange = np.arange(start=-floor_half_length, stop=floor_half_length + 1) + xx, yy = np.meshgrid(xrange, yrange) + xys = np.stack((yy, xx), axis=2).reshape(-1, 2) + vertices[:, 0] = xys[:, 0] + xy_origin[0] + vertices[:, 1] = xys[:, 1] + xy_origin[1] + vertices[:, 2] = altitude + normals = np.zeros((len(vertices), 3)) + normals[:, 2] = 1 + + mat = sapien.render.RenderMaterial() + mat.base_color_texture = sapien.render.RenderTexture2D( + filename=texture_file, + mipmap_levels=mipmap_levels, + ) + uv_scale = floor_width / texture_square_len + uvs = np.zeros((len(vertices), 2)) + uvs[:, 0] = (xys[:, 0] * uv_scale + floor_half_width) / floor_width + uvs[:, 1] = (xys[:, 1] * uv_scale + floor_half_width) / floor_width + + # TODO: This is fast but still two for loops which is a little annoying + triangles = [] + for i in range(floor_length): + triangles.append( + np.stack( + [ + np.arange(floor_width) + i * (floor_width + 1), + np.arange(floor_width) + 1 + floor_width + i * (floor_width + 1), + np.arange(floor_width) + 1 + i * (floor_width + 1), + ], + axis=1, + ) + ) + for i in range(floor_length): + triangles.append( + np.stack( + [ + np.arange(floor_width) + 1 + floor_width + i * (floor_width + 1), + np.arange(floor_width) + floor_width + 2 + i * (floor_width + 1), + np.arange(floor_width) + 1 + i * (floor_width + 1), + ], + axis=1, + ) + ) + triangles = np.concatenate(triangles) + + shape = sapien.render.RenderShapeTriangleMesh( + vertices=vertices, triangles=triangles, normals=normals, uvs=uvs, material=mat + ) + + for obj in actor._objs: + floor_comp = sapien.render.RenderBodyComponent() + floor_comp.attach(shape) + obj.add_component(floor_comp) + + return actor diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/mjcf_loader.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/mjcf_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..ae7db0b019ef82428703700366a1edfe1f1b28fe --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/mjcf_loader.py @@ -0,0 +1,113 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, List, TypedDict + +from mani_skill.utils.building.actor_builder import ActorBuilder +from mani_skill.utils.building.articulation_builder import ArticulationBuilder +from mani_skill.utils.structs import Actor, Articulation + +if TYPE_CHECKING: + from mani_skill.envs.scene import ManiSkillScene + +from ._mjcf_loader import MJCFLoader as SAPIENMJCFLoader + + +class ParsedMJCFData(TypedDict): + articulation_builders: List[ArticulationBuilder] + actor_builders: List[ActorBuilder] + cameras: List[Any] + + +class MJCFLoader(SAPIENMJCFLoader): + """ + Wrapper for the SAPIEN MJCF Loader to support easy parallelization + """ + + scene: ManiSkillScene + name: str = None + disable_self_collisions: bool = False + + def parse(self, mjcf_file, package_dir=None) -> ParsedMJCFData: + articulation_builders, actor_builders, cameras = super().parse( + mjcf_file, package_dir + ) + for i, a in enumerate(articulation_builders): + if len(articulation_builders) > 1: + a.set_name(f"{self.name}-articulation-{i}") + else: + a.set_name(f"{self.name}") + if self.disable_self_collisions: + for l in a.link_builders: + # NOTE (stao): Currently this may not be working as intended + l.collision_groups[2] |= 1 << 29 + for i, b in enumerate(actor_builders): + b.set_name(f"{self.name}-actor-{i}") + return dict( + articulation_builders=articulation_builders, + actor_builders=actor_builders, + cameras=cameras, + ) + + def load( + self, + mjcf_file: str, + package_dir=None, + name=None, + scene_idxs=None, + ) -> Articulation: + """ + Args: + urdf_file: filename for URDL file + srdf_file: SRDF for urdf_file. If srdf_file is None, it defaults to the ".srdf" file with the same as the urdf file + package_dir: base directory used to resolve asset files in the URDF file. If an asset path starts with "package://", "package://" is simply removed from the file name + name (str): name of the created articulation + scene_idxs (list[int]): the ids of the scenes to build the objects in + Returns: + returns a single Articulation loaded from the URDF file. It throws an error if multiple objects exists + """ + if name is not None: + self.name = name + _parsed_mjcf_data = self.parse(mjcf_file, package_dir) + articulation_builders = _parsed_mjcf_data["articulation_builders"] + _parsed_mjcf_data["actor_builders"] + cameras = _parsed_mjcf_data["cameras"] + + articulations: List[Articulation] = [] + for b in articulation_builders[:1]: + b.set_scene_idxs(scene_idxs) + b.disable_self_collisions = self.disable_self_collisions + articulations.append(b.build()) + + actors: List[Actor] = [] + # for b in actor_builders: + # actors.append(b.build()) + + if len(cameras) > 0: + name2entity = dict() + for a in articulations: + for sapien_articulation in a._objs: + for l in sapien_articulation.links: + name2entity[l.name] = l.entity + + for a in actors: + name2entity[a.name] = a + + # TODO (stao): support extracting sensors + # for scene_idx, scene in enumerate(self.scene.sub_scenes): + # for cam in cameras: + # cam_component = RenderCameraComponent(cam["width"], cam["height"]) + # if cam["fovx"] is not None and cam["fovy"] is not None: + # cam_component.set_fovx(cam["fovx"], False) + # cam_component.set_fovy(cam["fovy"], False) + # elif cam["fovy"] is None: + # cam_component.set_fovx(cam["fovx"], True) + # elif cam["fovx"] is None: + # cam_component.set_fovy(cam["fovy"], True) + + # cam_component.near = cam["near"] + # cam_component.far = cam["far"] + # name2entity[f"scene-{scene_idx}_{cam['reference']}"].add_component( + # cam_component + # ) + + return articulations[0] diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/urdf_loader.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/urdf_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..cd7be753d083e6e5a2d8cc15f3959cb6d555f284 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/urdf_loader.py @@ -0,0 +1,123 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, List, TypedDict + +from sapien.render import RenderCameraComponent +from sapien.wrapper.urdf_loader import URDFLoader as SapienURDFLoader + +from mani_skill.utils.building.actor_builder import ActorBuilder +from mani_skill.utils.building.articulation_builder import ArticulationBuilder +from mani_skill.utils.structs.actor import Actor +from mani_skill.utils.structs.articulation import Articulation + +if TYPE_CHECKING: + from mani_skill.envs.scene import ManiSkillScene + + +class ParsedURDFData(TypedDict): + articulation_builders: List[ArticulationBuilder] + actor_builders: List[ActorBuilder] + cameras: List[Any] + + +class URDFLoader(SapienURDFLoader): + scene: ManiSkillScene + name: str = None + disable_self_collisions: bool = False + + def parse(self, urdf_file, srdf_file=None, package_dir=None) -> ParsedURDFData: + articulation_builders, actor_builders, cameras = super().parse( + urdf_file, srdf_file, package_dir + ) + for i, a in enumerate(articulation_builders): + if len(articulation_builders) > 1: + a.set_name(f"{self.name}-articulation-{i}") + else: + a.set_name(f"{self.name}") + if self.disable_self_collisions: + for l in a.link_builders: + # NOTE (stao): Currently this may not be working as intended + l.collision_groups[2] |= 1 << 29 + for i, b in enumerate(actor_builders): + b.set_name(f"{self.name}-actor-{i}") + return dict( + articulation_builders=articulation_builders, + actor_builders=actor_builders, + cameras=cameras, + ) + + def load_file_as_articulation_builder( + self, urdf_file, srdf_file=None, package_dir=None + ) -> ArticulationBuilder: + return super().load_file_as_articulation_builder( + urdf_file, srdf_file, package_dir + ) + + def load( + self, + urdf_file: str, + srdf_file=None, + package_dir=None, + name=None, + scene_idxs=None, + ) -> Articulation: + """ + Args: + urdf_file: filename for URDL file + srdf_file: SRDF for urdf_file. If srdf_file is None, it defaults to the ".srdf" file with the same as the urdf file + package_dir: base directory used to resolve asset files in the URDF file. If an asset path starts with "package://", "package://" is simply removed from the file name + name (str): name of the created articulation + scene_idxs (list[int]): the ids of the scenes to build the objects in + Returns: + returns a single Articulation loaded from the URDF file. It throws an error if multiple objects exists + """ + if name is not None: + self.name = name + _parsed_urdf_data = self.parse(urdf_file, srdf_file, package_dir) + articulation_builders = _parsed_urdf_data["articulation_builders"] + actor_builders = _parsed_urdf_data["actor_builders"] + cameras = _parsed_urdf_data["cameras"] + + if len(articulation_builders) > 1 or len(actor_builders) != 0: + raise Exception( + "URDF contains multiple objects, call load_multiple instead" + ) + + articulations: List[Articulation] = [] + for b in articulation_builders: + b.set_scene_idxs(scene_idxs) + b.disable_self_collisions = self.disable_self_collisions + articulations.append(b.build()) + + actors: List[Actor] = [] + for b in actor_builders: + actors.append(b.build()) + + if len(cameras) > 0: + name2entity = dict() + for a in articulations: + for sapien_articulation in a._objs: + for l in sapien_articulation.links: + name2entity[l.name] = l.entity + + for a in actors: + name2entity[a.name] = a + + for scene_idx, scene in enumerate(self.scene.sub_scenes): + for cam in cameras: + cam_component = RenderCameraComponent(cam["width"], cam["height"]) + if cam["fovx"] is not None and cam["fovy"] is not None: + cam_component.set_fovx(cam["fovx"], False) + cam_component.set_fovy(cam["fovy"], False) + elif cam["fovy"] is None: + cam_component.set_fovx(cam["fovx"], True) + elif cam["fovx"] is None: + cam_component.set_fovy(cam["fovy"], True) + + cam_component.near = cam["near"] + cam_component.far = cam["far"] + name2entity[f"scene-{scene_idx}_{cam['reference']}"].add_component( + cam_component + ) + + return articulations[0] diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9854a4218f973a0527cdf3d118bea8f319452300 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__init__.py @@ -0,0 +1 @@ +from .geometry import * diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..755e1f8bbba98b9f0ed41bf8809f4f7a3768459f Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/bounding_cylinder.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/bounding_cylinder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f9923517102b5fa086181999150d966c46b70402 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/bounding_cylinder.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/geometry.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/geometry.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8cce6f380179552102f0500546b87ef6e4cec58b Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/geometry.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/rotation_conversions.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/rotation_conversions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e4a6ed37a261fc244440263ca6bc99247e36c67a Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/rotation_conversions.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/trimesh_utils.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/trimesh_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1f8d499c635804a8b046ed8960f8d8aa54eac73 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__pycache__/trimesh_utils.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/bounding_cylinder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/bounding_cylinder.py new file mode 100644 index 0000000000000000000000000000000000000000..395c13a09a238f0c9047cd8ca96631b36afa1467 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/bounding_cylinder.py @@ -0,0 +1,137 @@ +# +# Smallest enclosing circle - Library (Python) +# +# Copyright (c) 2020 Project Nayuki +# https://www.nayuki.io/page/smallest-enclosing-circle +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with this program (see COPYING.txt and COPYING.LESSER.txt). +# If not, see . +# + +# fmt: off +# isort: skip_file +import math, random +import numpy as np + + +# Data conventions: A point is a pair of floats (x, y). A circle is a triple of floats (center x, center y, radius). + +# Returns the smallest circle that encloses all the given points. Runs in expected O(n) time, randomized. +# Input: A sequence of pairs of floats or ints, e.g. [(0,5), (3.1,-2.7)]. +# Output: A triple of floats representing a circle. +# Note: If 0 points are given, None is returned. If 1 point is given, a circle of radius 0 is returned. +# +# Initially: No boundary points known +def make_circle(points): + # Convert to float and randomize order + shuffled = [(float(x), float(y)) for (x, y) in points] + random.shuffle(shuffled) + + # Progressively add points to circle or recompute circle + c = None + for (i, p) in enumerate(shuffled): + if c is None or not is_in_circle(c, p): + c = _make_circle_one_point(shuffled[ : i + 1], p) + return c + + +# One boundary point known +def _make_circle_one_point(points, p): + c = (p[0], p[1], 0.0) + for (i, q) in enumerate(points): + if not is_in_circle(c, q): + if c[2] == 0.0: + c = make_diameter(p, q) + else: + c = _make_circle_two_points(points[ : i + 1], p, q) + return c + + +# Two boundary points known +def _make_circle_two_points(points, p, q): + circ = make_diameter(p, q) + left = None + right = None + px, py = p + qx, qy = q + + # For each point not in the two-point circle + for r in points: + if is_in_circle(circ, r): + continue + + # Form a circumcircle and classify it on left or right side + cross = _cross_product(px, py, qx, qy, r[0], r[1]) + c = make_circumcircle(p, q, r) + if c is None: + continue + elif cross > 0.0 and (left is None or _cross_product(px, py, qx, qy, c[0], c[1]) > _cross_product(px, py, qx, qy, left[0], left[1])): + left = c + elif cross < 0.0 and (right is None or _cross_product(px, py, qx, qy, c[0], c[1]) < _cross_product(px, py, qx, qy, right[0], right[1])): + right = c + + # Select which circle to return + if left is None and right is None: + return circ + elif left is None: + return right + elif right is None: + return left + else: + return left if (left[2] <= right[2]) else right + + +def make_diameter(a, b): + cx = (a[0] + b[0]) / 2 + cy = (a[1] + b[1]) / 2 + r0 = math.hypot(cx - a[0], cy - a[1]) + r1 = math.hypot(cx - b[0], cy - b[1]) + return (cx, cy, max(r0, r1)) + + +def make_circumcircle(a, b, c): + # Mathematical algorithm from Wikipedia: Circumscribed circle + ox = (min(a[0], b[0], c[0]) + max(a[0], b[0], c[0])) / 2 + oy = (min(a[1], b[1], c[1]) + max(a[1], b[1], c[1])) / 2 + ax = a[0] - ox; ay = a[1] - oy + bx = b[0] - ox; by = b[1] - oy + cx = c[0] - ox; cy = c[1] - oy + d = (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by)) * 2.0 + if d == 0.0: + return None + x = ox + ((ax*ax + ay*ay) * (by - cy) + (bx*bx + by*by) * (cy - ay) + (cx*cx + cy*cy) * (ay - by)) / d + y = oy + ((ax*ax + ay*ay) * (cx - bx) + (bx*bx + by*by) * (ax - cx) + (cx*cx + cy*cy) * (bx - ax)) / d + ra = math.hypot(x - a[0], y - a[1]) + rb = math.hypot(x - b[0], y - b[1]) + rc = math.hypot(x - c[0], y - c[1]) + return (x, y, max(ra, rb, rc)) + + +_MULTIPLICATIVE_EPSILON = 1 + 1e-14 + +def is_in_circle(c, p): + return c is not None and math.hypot(p[0] - c[0], p[1] - c[1]) <= c[2] * _MULTIPLICATIVE_EPSILON + + +# Returns twice the signed area of the triangle defined by (x0, y0), (x1, y1), (x2, y2). +def _cross_product(x0, y0, x1, y1, x2, y2): + return (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0) + + +def aabc(points): + points = np.asarray(points) + z_min = points[:, 2].min() + z_max = points[:, 2].max() + x, y, r = make_circle(points[:, :2]) + return x, y, r, z_min, z_max diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/geometry.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/geometry.py new file mode 100644 index 0000000000000000000000000000000000000000..a4ca76eb7882b4ce91a39f5b2ab45e14e5630033 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/geometry.py @@ -0,0 +1,201 @@ +from typing import Dict + +import numpy as np +import sapien +import sapien.physx as physx +import torch +from scipy.spatial.transform import Rotation + +from mani_skill.utils.geometry.bounding_cylinder import aabc + + +def sample_on_unit_sphere(rng): + """ + Algo from http://corysimon.github.io/articles/uniformdistn-on-sphere/ + """ + v = np.zeros(3) + while np.linalg.norm(v) < 1e-4: + v[0] = rng.normal() # random standard normal + v[1] = rng.normal() + v[2] = rng.normal() + + v = v / np.linalg.norm(v) + return v + + +def sample_on_unit_circle(rng): + v = np.zeros(2) + while np.linalg.norm(v) < 1e-4: + v[0] = rng.normal() # random standard normal + v[1] = rng.normal() + + v = v / np.linalg.norm(v) + return v + + +def rotation_between_vec(a, b): # from a to b + a = a / np.linalg.norm(a) + b = b / np.linalg.norm(b) + axis = np.cross(a, b) + axis = axis / np.linalg.norm(axis) # norm might be 0 + angle = np.arccos(a @ b) + R = Rotation.from_rotvec(axis * angle) + return R + + +def angle_between_vec(a, b): # from a to b + a = a / np.linalg.norm(a) + b = b / np.linalg.norm(b) + angle = np.arccos(a @ b) + return angle + + +def wxyz_to_xyzw(q): + return np.concatenate([q[1:4], q[0:1]]) + + +def xyzw_to_wxyz(q): + return np.concatenate([q[3:4], q[0:3]]) + + +def rotate_2d_vec_by_angle(vec, theta): + rot_mat = np.array( + [[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]] + ) + return rot_mat @ vec + + +def angle_distance(q0: sapien.Pose, q1: sapien.Pose): + qd = (q0.inv() * q1).q + return 2 * np.arctan2(np.linalg.norm(qd[1:]), qd[0]) / np.pi + + +def get_axis_aligned_bbox_for_articulation(art: physx.PhysxArticulation): + mins = np.array([np.inf, np.inf, np.inf]) + maxs = -mins + for link in art.get_links(): + lp = link.pose + for s in link.get_collision_shapes(): + p = lp * s.get_local_pose() + T = p.to_transformation_matrix() + assert isinstance(s, physx.PhysxCollisionShapeConvexMesh) + vertices = s.vertices * s.scale + vertices = vertices @ T[:3, :3].T + T[:3, 3] + mins = np.minimum(mins, vertices.min(0)) + maxs = np.maximum(maxs, vertices.max(0)) + return mins, maxs + + +def get_axis_aligned_bbox_for_actor(actor: sapien.Entity): + mins = np.ones(3) * np.inf + maxs = -mins + + for shape in actor.find_component_by_type( + physx.PhysxRigidDynamicComponent + ).get_collision_shapes(): # this is CollisionShape + assert isinstance(shape, physx.PhysxCollisionShapeConvexMesh) + scaled_vertices = shape.vertices * shape.scale + local_pose = shape.get_local_pose() + mat = (actor.get_pose() * local_pose).to_transformation_matrix() + world_vertices = scaled_vertices @ (mat[:3, :3].T) + mat[:3, 3] + mins = np.minimum(mins, world_vertices.min(0)) + maxs = np.maximum(maxs, world_vertices.max(0)) + + return mins, maxs + + +def get_local_axis_aligned_bbox_for_link(link: physx.PhysxArticulationLinkComponent): + mins = np.array([np.inf, np.inf, np.inf]) + maxs = -mins + for s in link.get_collision_shapes(): + assert isinstance(s, physx.PhysxCollisionShapeConvexMesh) + p = s.get_local_pose() + T = p.to_transformation_matrix() + vertices = s.vertices * s.scale + vertices = vertices @ T[:3, :3].T + T[:3, 3] + mins = np.minimum(mins, vertices.min(0)) + maxs = np.maximum(maxs, vertices.max(0)) + return mins, maxs + + +def get_local_aabc_for_actor(actor: sapien.Entity): + all_vertices = [] + for s in actor.find_component_by_type( + physx.PhysxRigidDynamicComponent + ).get_collision_shapes(): + assert isinstance(s, physx.PhysxCollisionShapeConvexMesh) + p = s.get_local_pose() + T = p.to_transformation_matrix() + vertices = s.vertices * s.scale + vertices = vertices @ T[:3, :3].T + T[:3, 3] + all_vertices.append(vertices) + vertices = np.vstack(all_vertices) + return aabc(vertices) + + +def transform_points(H: torch.Tensor, pts: torch.Tensor) -> torch.Tensor: + """transforms a batch of pts by a batch of transformation matrices H""" + assert H.shape[1:] == (4, 4), H.shape + assert pts.ndim == 2 and pts.shape[1] == 3, pts.shape + return ( + torch.bmm(pts[:, None, :], H[:, :3, :3].transpose(2, 1))[:, 0, :] + H[:, :3, 3] + ) + + +def invert_transform(H: np.ndarray): + assert H.shape[-2:] == (4, 4), H.shape + H_inv = H.copy() + R_T = np.swapaxes(H[..., :3, :3], -1, -2) + H_inv[..., :3, :3] = R_T + H_inv[..., :3, 3:] = -R_T @ H[..., :3, 3:] + return H_inv + + +def get_oriented_bounding_box_for_2d_points( + points_2d: np.ndarray, resolution=0.0 +) -> Dict: + assert len(points_2d.shape) == 2 and points_2d.shape[1] == 2 + if resolution > 0.0: + points_2d = np.round(points_2d / resolution) * resolution + points_2d = np.unique(points_2d, axis=0) + ca = np.cov(points_2d, y=None, rowvar=0, bias=1) + + v, vect = np.linalg.eig(ca) + tvect = np.transpose(vect) + + # use the inverse of the eigenvectors as a rotation matrix and + # rotate the points so they align with the x and y axes + ar = np.dot(points_2d, np.linalg.inv(tvect)) + + # get the minimum and maximum x and y + mina = np.min(ar, axis=0) + maxa = np.max(ar, axis=0) + half_size = (maxa - mina) * 0.5 + + # the center is just half way between the min and max xy + center = mina + half_size + # get the 4 corners by subtracting and adding half the bounding boxes height and width to the center + corners = np.array( + [ + center + [-half_size[0], -half_size[1]], + center + [half_size[0], -half_size[1]], + center + [half_size[0], half_size[1]], + center + [-half_size[0], half_size[1]], + ] + ) + + # use the the eigenvectors as a rotation matrix and + # rotate the corners and the centerback + corners = np.dot(corners, tvect) + center = np.dot(center, tvect) + + return {"center": center, "half_size": half_size, "axes": vect, "corners": corners} + + +# -------------------------------------------------------------------------- # +# Functions pulled out from SAPIEN +# -------------------------------------------------------------------------- # +def rotate_vector(v, q): + w = q[0] + u = q[1:] + return 2.0 * u.dot(v) * u + (w * w - u.dot(u)) * v + 2.0 * w * np.cross(u, v) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/rotation_conversions.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/rotation_conversions.py new file mode 100644 index 0000000000000000000000000000000000000000..2ad078510ceedf205799edc6458a48a28a785cdc --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/rotation_conversions.py @@ -0,0 +1,633 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Optional, Union + +import torch +import torch.nn.functional as F + +Device = Union[str, torch.device] + +# -------------------------------------------------------------------------- # +# Functions pulled out from pytorch3d to avoid having to install the whole package +# -------------------------------------------------------------------------- # + +""" +The transformation matrices returned from the functions in this file assume +the points on which the transformation will be applied are column vectors. +i.e. the R matrix is structured as + + R = [ + [Rxx, Rxy, Rxz], + [Ryx, Ryy, Ryz], + [Rzx, Rzy, Rzz], + ] # (3, 3) + +This matrix can be applied to column vectors by post multiplication +by the points e.g. + + points = [[0], [1], [2]] # (3 x 1) xyz coordinates of a point + transformed_points = R * points + +To apply the same matrix to points which are row vectors, the R matrix +can be transposed and pre multiplied by the points: + +e.g. + points = [[0, 1, 2]] # (1 x 3) xyz coordinates of a point + transformed_points = points * R.transpose(1, 0) +""" + + +def quaternion_to_matrix(quaternions: torch.Tensor) -> torch.Tensor: + """ + Convert rotations given as quaternions to rotation matrices. + + Args: + quaternions: quaternions with real part first, + as tensor of shape (..., 4). + + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + r, i, j, k = torch.unbind(quaternions, -1) + # pyre-fixme[58]: `/` is not supported for operand types `float` and `Tensor`. + two_s = 2.0 / (quaternions * quaternions).sum(-1) + + o = torch.stack( + ( + 1 - two_s * (j * j + k * k), + two_s * (i * j - k * r), + two_s * (i * k + j * r), + two_s * (i * j + k * r), + 1 - two_s * (i * i + k * k), + two_s * (j * k - i * r), + two_s * (i * k - j * r), + two_s * (j * k + i * r), + 1 - two_s * (i * i + j * j), + ), + -1, + ) + return o.reshape(quaternions.shape[:-1] + (3, 3)) + + +def _copysign(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor: + """ + Return a tensor where each element has the absolute value taken from the, + corresponding element of a, with sign taken from the corresponding + element of b. This is like the standard copysign floating-point operation, + but is not careful about negative 0 and NaN. + + Args: + a: source tensor. + b: tensor whose signs will be used, of the same shape as a. + + Returns: + Tensor of the same shape as a with the signs of b. + """ + signs_differ = (a < 0) != (b < 0) + return torch.where(signs_differ, -a, a) + + +def _sqrt_positive_part(x: torch.Tensor) -> torch.Tensor: + """ + Returns torch.sqrt(torch.max(0, x)) + but with a zero subgradient where x is 0. + """ + ret = torch.zeros_like(x) + positive_mask = x > 0 + ret[positive_mask] = torch.sqrt(x[positive_mask]) + return ret + + +def matrix_to_quaternion(matrix: torch.Tensor) -> torch.Tensor: + """ + Convert rotations given as rotation matrices to quaternions. + + Args: + matrix: Rotation matrices as tensor of shape (..., 3, 3). + + Returns: + quaternions with real part first, as tensor of shape (..., 4). + """ + if matrix.size(-1) != 3 or matrix.size(-2) != 3: + raise ValueError(f"Invalid rotation matrix shape {matrix.shape}.") + + batch_dim = matrix.shape[:-2] + m00, m01, m02, m10, m11, m12, m20, m21, m22 = torch.unbind( + matrix.reshape(batch_dim + (9,)), dim=-1 + ) + + q_abs = _sqrt_positive_part( + torch.stack( + [ + 1.0 + m00 + m11 + m22, + 1.0 + m00 - m11 - m22, + 1.0 - m00 + m11 - m22, + 1.0 - m00 - m11 + m22, + ], + dim=-1, + ) + ) + + # we produce the desired quaternion multiplied by each of r, i, j, k + quat_by_rijk = torch.stack( + [ + # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and + # `int`. + torch.stack([q_abs[..., 0] ** 2, m21 - m12, m02 - m20, m10 - m01], dim=-1), + # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and + # `int`. + torch.stack([m21 - m12, q_abs[..., 1] ** 2, m10 + m01, m02 + m20], dim=-1), + # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and + # `int`. + torch.stack([m02 - m20, m10 + m01, q_abs[..., 2] ** 2, m12 + m21], dim=-1), + # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and + # `int`. + torch.stack([m10 - m01, m20 + m02, m21 + m12, q_abs[..., 3] ** 2], dim=-1), + ], + dim=-2, + ) + + # We floor here at 0.1 but the exact level is not important; if q_abs is small, + # the candidate won't be picked. + flr = torch.tensor(0.1).to(dtype=q_abs.dtype, device=q_abs.device) + quat_candidates = quat_by_rijk / (2.0 * q_abs[..., None].max(flr)) + + # if not for numerical problems, quat_candidates[i] should be same (up to a sign), + # forall i; we pick the best-conditioned one (with the largest denominator) + out = quat_candidates[ + F.one_hot(q_abs.argmax(dim=-1), num_classes=4) > 0.5, : + ].reshape(batch_dim + (4,)) + return standardize_quaternion(out) + + +def _axis_angle_rotation(axis: str, angle: torch.Tensor) -> torch.Tensor: + """ + Return the rotation matrices for one of the rotations about an axis + of which Euler angles describe, for each value of the angle given. + + Args: + axis: Axis label "X" or "Y or "Z". + angle: any shape tensor of Euler angles in radians + + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + + cos = torch.cos(angle) + sin = torch.sin(angle) + one = torch.ones_like(angle) + zero = torch.zeros_like(angle) + + if axis == "X": + R_flat = (one, zero, zero, zero, cos, -sin, zero, sin, cos) + elif axis == "Y": + R_flat = (cos, zero, sin, zero, one, zero, -sin, zero, cos) + elif axis == "Z": + R_flat = (cos, -sin, zero, sin, cos, zero, zero, zero, one) + else: + raise ValueError("letter must be either X, Y or Z.") + + return torch.stack(R_flat, -1).reshape(angle.shape + (3, 3)) + + +def euler_angles_to_matrix(euler_angles: torch.Tensor, convention: str) -> torch.Tensor: + """ + Convert rotations given as Euler angles in radians to rotation matrices. + + Args: + euler_angles: Euler angles in radians as tensor of shape (..., 3). + convention: Convention string of three uppercase letters from + {"X", "Y", and "Z"}. + + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + if euler_angles.dim() == 0 or euler_angles.shape[-1] != 3: + raise ValueError("Invalid input euler angles.") + if len(convention) != 3: + raise ValueError("Convention must have 3 letters.") + if convention[1] in (convention[0], convention[2]): + raise ValueError(f"Invalid convention {convention}.") + for letter in convention: + if letter not in ("X", "Y", "Z"): + raise ValueError(f"Invalid letter {letter} in convention string.") + matrices = [ + _axis_angle_rotation(c, e) + for c, e in zip(convention, torch.unbind(euler_angles, -1)) + ] + # return functools.reduce(torch.matmul, matrices) + return torch.matmul(torch.matmul(matrices[0], matrices[1]), matrices[2]) + + +def _angle_from_tan( + axis: str, other_axis: str, data, horizontal: bool, tait_bryan: bool +) -> torch.Tensor: + """ + Extract the first or third Euler angle from the two members of + the matrix which are positive constant times its sine and cosine. + + Args: + axis: Axis label "X" or "Y or "Z" for the angle we are finding. + other_axis: Axis label "X" or "Y or "Z" for the middle axis in the + convention. + data: Rotation matrices as tensor of shape (..., 3, 3). + horizontal: Whether we are looking for the angle for the third axis, + which means the relevant entries are in the same row of the + rotation matrix. If not, they are in the same column. + tait_bryan: Whether the first and third axes in the convention differ. + + Returns: + Euler Angles in radians for each matrix in data as a tensor + of shape (...). + """ + + i1, i2 = {"X": (2, 1), "Y": (0, 2), "Z": (1, 0)}[axis] + if horizontal: + i2, i1 = i1, i2 + even = (axis + other_axis) in ["XY", "YZ", "ZX"] + if horizontal == even: + return torch.atan2(data[..., i1], data[..., i2]) + if tait_bryan: + return torch.atan2(-data[..., i2], data[..., i1]) + return torch.atan2(data[..., i2], -data[..., i1]) + + +def _index_from_letter(letter: str) -> int: + if letter == "X": + return 0 + if letter == "Y": + return 1 + if letter == "Z": + return 2 + raise ValueError("letter must be either X, Y or Z.") + + +def matrix_to_euler_angles(matrix: torch.Tensor, convention: str) -> torch.Tensor: + """ + Convert rotations given as rotation matrices to Euler angles in radians. + + Args: + matrix: Rotation matrices as tensor of shape (..., 3, 3). + convention: Convention string of three uppercase letters. + + Returns: + Euler angles in radians as tensor of shape (..., 3). + """ + if len(convention) != 3: + raise ValueError("Convention must have 3 letters.") + if convention[1] in (convention[0], convention[2]): + raise ValueError(f"Invalid convention {convention}.") + for letter in convention: + if letter not in ("X", "Y", "Z"): + raise ValueError(f"Invalid letter {letter} in convention string.") + if matrix.size(-1) != 3 or matrix.size(-2) != 3: + raise ValueError(f"Invalid rotation matrix shape {matrix.shape}.") + i0 = _index_from_letter(convention[0]) + i2 = _index_from_letter(convention[2]) + tait_bryan = i0 != i2 + if tait_bryan: + central_angle = torch.asin( + matrix[..., i0, i2] * (-1.0 if i0 - i2 in [-1, 2] else 1.0) + ) + else: + central_angle = torch.acos(matrix[..., i0, i0]) + + o = ( + _angle_from_tan( + convention[0], convention[1], matrix[..., i2], False, tait_bryan + ), + central_angle, + _angle_from_tan( + convention[2], convention[1], matrix[..., i0, :], True, tait_bryan + ), + ) + return torch.stack(o, -1) + + +def random_quaternions( + n: int, dtype: Optional[torch.dtype] = None, device: Optional[Device] = None +) -> torch.Tensor: + """ + Generate random quaternions representing rotations, + i.e. versors with nonnegative real part. + + Args: + n: Number of quaternions in a batch to return. + dtype: Type to return. + device: Desired device of returned tensor. Default: + uses the current device for the default tensor type. + + Returns: + Quaternions as tensor of shape (N, 4). + """ + if isinstance(device, str): + device = torch.device(device) + o = torch.randn((n, 4), dtype=dtype, device=device) + s = (o * o).sum(1) + o = o / _copysign(torch.sqrt(s), o[:, 0])[:, None] + return o + + +def random_rotations( + n: int, dtype: Optional[torch.dtype] = None, device: Optional[Device] = None +) -> torch.Tensor: + """ + Generate random rotations as 3x3 rotation matrices. + + Args: + n: Number of rotation matrices in a batch to return. + dtype: Type to return. + device: Device of returned tensor. Default: if None, + uses the current device for the default tensor type. + + Returns: + Rotation matrices as tensor of shape (n, 3, 3). + """ + quaternions = random_quaternions(n, dtype=dtype, device=device) + return quaternion_to_matrix(quaternions) + + +def random_rotation( + dtype: Optional[torch.dtype] = None, device: Optional[Device] = None +) -> torch.Tensor: + """ + Generate a single random 3x3 rotation matrix. + + Args: + dtype: Type to return + device: Device of returned tensor. Default: if None, + uses the current device for the default tensor type + + Returns: + Rotation matrix as tensor of shape (3, 3). + """ + return random_rotations(1, dtype, device)[0] + + +def standardize_quaternion(quaternions: torch.Tensor) -> torch.Tensor: + """ + Convert a unit quaternion to a standard form: one in which the real + part is non negative. + + Args: + quaternions: Quaternions with real part first, + as tensor of shape (..., 4). + + Returns: + Standardized quaternions as tensor of shape (..., 4). + """ + return torch.where(quaternions[..., 0:1] < 0, -quaternions, quaternions) + + +def quaternion_raw_multiply(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor: + """ + Multiply two quaternions. + Usual torch rules for broadcasting apply. + + Args: + a: Quaternions as tensor of shape (..., 4), real part first. + b: Quaternions as tensor of shape (..., 4), real part first. + + Returns: + The product of a and b, a tensor of quaternions shape (..., 4). + """ + aw, ax, ay, az = torch.unbind(a, -1) + bw, bx, by, bz = torch.unbind(b, -1) + ow = aw * bw - ax * bx - ay * by - az * bz + ox = aw * bx + ax * bw + ay * bz - az * by + oy = aw * by - ax * bz + ay * bw + az * bx + oz = aw * bz + ax * by - ay * bx + az * bw + return torch.stack((ow, ox, oy, oz), -1) + + +def quaternion_multiply(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor: + """ + Multiply two quaternions representing rotations, returning the quaternion + representing their composition, i.e. the versor with nonnegative real part. + Usual torch rules for broadcasting apply. + + Args: + a: Quaternions as tensor of shape (..., 4), real part first. + b: Quaternions as tensor of shape (..., 4), real part first. + + Returns: + The product of a and b, a tensor of quaternions of shape (..., 4). + """ + ab = quaternion_raw_multiply(a, b) + return standardize_quaternion(ab) + + +def quaternion_invert(quaternion: torch.Tensor) -> torch.Tensor: + """ + Given a quaternion representing rotation, get the quaternion representing + its inverse. + + Args: + quaternion: Quaternions as tensor of shape (..., 4), with real part + first, which must be versors (unit quaternions). + + Returns: + The inverse, a tensor of quaternions of shape (..., 4). + """ + + scaling = torch.tensor([1, -1, -1, -1], device=quaternion.device) + return quaternion * scaling + + +def quaternion_apply(quaternion: torch.Tensor, point: torch.Tensor) -> torch.Tensor: + """ + Apply the rotation given by a quaternion to a 3D point. + Usual torch rules for broadcasting apply. + + Args: + quaternion: Tensor of quaternions, real part first, of shape (..., 4). + point: Tensor of 3D points of shape (..., 3). + + Returns: + Tensor of rotated points of shape (..., 3). + """ + if point.size(-1) != 3: + raise ValueError(f"Points are not in 3D, {point.shape}.") + real_parts = point.new_zeros(point.shape[:-1] + (1,)) + point_as_quaternion = torch.cat((real_parts, point), -1) + out = quaternion_raw_multiply( + quaternion_raw_multiply(quaternion, point_as_quaternion), + quaternion_invert(quaternion), + ) + return out[..., 1:] + + +def axis_angle_to_matrix(axis_angle: torch.Tensor) -> torch.Tensor: + """ + Convert rotations given as axis/angle to rotation matrices. + + Args: + axis_angle: Rotations given as a vector in axis angle form, + as a tensor of shape (..., 3), where the magnitude is + the angle turned anticlockwise in radians around the + vector's direction. + + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + return quaternion_to_matrix(axis_angle_to_quaternion(axis_angle)) + + +def matrix_to_axis_angle(matrix: torch.Tensor) -> torch.Tensor: + """ + Convert rotations given as rotation matrices to axis/angle. + + Args: + matrix: Rotation matrices as tensor of shape (..., 3, 3). + + Returns: + Rotations given as a vector in axis angle form, as a tensor + of shape (..., 3), where the magnitude is the angle + turned anticlockwise in radians around the vector's + direction. + """ + return quaternion_to_axis_angle(matrix_to_quaternion(matrix)) + + +def axis_angle_to_quaternion(axis_angle: torch.Tensor) -> torch.Tensor: + """ + Convert rotations given as axis/angle to quaternions. + + Args: + axis_angle: Rotations given as a vector in axis angle form, + as a tensor of shape (..., 3), where the magnitude is + the angle turned anticlockwise in radians around the + vector's direction. + + Returns: + quaternions with real part first, as tensor of shape (..., 4). + """ + angles = torch.norm(axis_angle, p=2, dim=-1, keepdim=True) + half_angles = angles * 0.5 + eps = 1e-6 + small_angles = angles.abs() < eps + sin_half_angles_over_angles = torch.empty_like(angles) + sin_half_angles_over_angles[~small_angles] = ( + torch.sin(half_angles[~small_angles]) / angles[~small_angles] + ) + # for x small, sin(x/2) is about x/2 - (x/2)^3/6 + # so sin(x/2)/x is about 1/2 - (x*x)/48 + sin_half_angles_over_angles[small_angles] = ( + 0.5 - (angles[small_angles] * angles[small_angles]) / 48 + ) + quaternions = torch.cat( + [torch.cos(half_angles), axis_angle * sin_half_angles_over_angles], dim=-1 + ) + return quaternions + + +def quaternion_to_axis_angle(quaternions: torch.Tensor) -> torch.Tensor: + """ + Convert rotations given as quaternions to axis/angle. + + Args: + quaternions: quaternions with real part first, + as tensor of shape (..., 4). + + Returns: + Rotations given as a vector in axis angle form, as a tensor + of shape (..., 3), where the magnitude is the angle + turned anticlockwise in radians around the vector's + direction. + """ + norms = torch.norm(quaternions[..., 1:], p=2, dim=-1, keepdim=True) + half_angles = torch.atan2(norms, quaternions[..., :1]) + angles = 2 * half_angles + eps = 1e-6 + small_angles = angles.abs() < eps + sin_half_angles_over_angles = torch.empty_like(angles) + sin_half_angles_over_angles[~small_angles] = ( + torch.sin(half_angles[~small_angles]) / angles[~small_angles] + ) + # for x small, sin(x/2) is about x/2 - (x/2)^3/6 + # so sin(x/2)/x is about 1/2 - (x*x)/48 + sin_half_angles_over_angles[small_angles] = ( + 0.5 - (angles[small_angles] * angles[small_angles]) / 48 + ) + return quaternions[..., 1:] / sin_half_angles_over_angles + + +def rotation_6d_to_matrix(d6: torch.Tensor) -> torch.Tensor: + """ + Converts 6D rotation representation by Zhou et al. [1] to rotation matrix + using Gram--Schmidt orthogonalization per Section B of [1]. + Args: + d6: 6D rotation representation, of size (*, 6) + + Returns: + batch of rotation matrices of size (*, 3, 3) + + [1] Zhou, Y., Barnes, C., Lu, J., Yang, J., & Li, H. + On the Continuity of Rotation Representations in Neural Networks. + IEEE Conference on Computer Vision and Pattern Recognition, 2019. + Retrieved from http://arxiv.org/abs/1812.07035 + """ + + a1, a2 = d6[..., :3], d6[..., 3:] + b1 = F.normalize(a1, dim=-1) + b2 = a2 - (b1 * a2).sum(-1, keepdim=True) * b1 + b2 = F.normalize(b2, dim=-1) + b3 = torch.cross(b1, b2, dim=-1) + return torch.stack((b1, b2, b3), dim=-2) + + +def matrix_to_rotation_6d(matrix: torch.Tensor) -> torch.Tensor: + """ + Converts rotation matrices to 6D rotation representation by Zhou et al. [1] + by dropping the last row. Note that 6D representation is not unique. + Args: + matrix: batch of rotation matrices of size (*, 3, 3) + + Returns: + 6D rotation representation, of size (*, 6) + + [1] Zhou, Y., Barnes, C., Lu, J., Yang, J., & Li, H. + On the Continuity of Rotation Representations in Neural Networks. + IEEE Conference on Computer Vision and Pattern Recognition, 2019. + Retrieved from http://arxiv.org/abs/1812.07035 + """ + batch_dim = matrix.size()[:-2] + return matrix[..., :2, :].clone().reshape(batch_dim + (6,)) + +def euler_to_quaternion(euler_angles: torch.Tensor, convention: str = "ZYX") -> torch.Tensor: + """ + Convert rotations given as Euler angles in radians to quaternions. + + Args: + euler_angles: Euler angles in radians as a tensor of shape (..., 3). + convention: Convention string of three uppercase letters from {"X", "Y", "Z"}. + Specifies the order of rotations (e.g., "ZYX" for yaw-pitch-roll). + Defaults to "ZYX". + + Returns: + Quaternions with real part first, as a tensor of shape (..., 4). + """ + rotation_matrix = euler_angles_to_matrix(euler_angles, convention) + return matrix_to_quaternion(rotation_matrix) + +def quaternion_to_euler(quaternions: torch.Tensor, convention: str = "ZYX") -> torch.Tensor: + """ + Convert rotations given as quaternions to Euler angles in radians. + + Args: + quaternions: Quaternions with real part first, as tensor of shape (..., 4). + convention: Convention string of three uppercase letters from {"X", "Y", "Z"}. + Specifies the order of rotations (e.g., "ZYX" for yaw-pitch-roll). + Defaults to "ZYX". + + Returns: + Euler angles in radians as tensor of shape (..., 3). + """ + # First, convert the quaternion to a rotation matrix. + rotation_matrix = quaternion_to_matrix(quaternions) + # Next, convert the rotation matrix to Euler angles using the specified convention. + return matrix_to_euler_angles(rotation_matrix, convention) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/trimesh_utils.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/trimesh_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..41920a605fd88e51acdfcbea8cc0cf24ae7d5339 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/trimesh_utils.py @@ -0,0 +1,119 @@ +from typing import List + +## TODO clean up the code here, too many functions that are plurals of one or the other and confusing naming +import numpy as np +import sapien +import sapien.physx as physx +import sapien.render +import trimesh +import trimesh.creation + + +def get_component_meshes(component: physx.PhysxRigidBaseComponent): + """Get component (collision) meshes in the component's frame.""" + meshes = [] + for geom in component.get_collision_shapes(): + if isinstance(geom, physx.PhysxCollisionShapeBox): + mesh = trimesh.creation.box(extents=2 * geom.half_size) + elif isinstance(geom, physx.PhysxCollisionShapeCapsule): + mesh = trimesh.creation.capsule( + height=2 * geom.half_length, radius=geom.radius + ) + + elif isinstance(geom, physx.PhysxCollisionShapeCylinder): + mesh = trimesh.creation.cylinder( + radius=geom.radius, height=2 * geom.half_length + ) + elif isinstance(geom, physx.PhysxCollisionShapeSphere): + mesh = trimesh.creation.icosphere(radius=geom.radius) + elif isinstance(geom, physx.PhysxCollisionShapePlane): + continue + elif isinstance(geom, (physx.PhysxCollisionShapeConvexMesh)): + vertices = geom.vertices # [n, 3] + faces = geom.get_triangles() + vertices = vertices * geom.scale + mesh = trimesh.Trimesh(vertices=vertices, faces=faces) + elif isinstance(geom, physx.PhysxCollisionShapeTriangleMesh): + vertices = geom.vertices + faces = geom.get_triangles() + vertices = vertices * geom.scale + mesh = trimesh.Trimesh(vertices=vertices, faces=faces) + else: + raise TypeError(type(geom)) + mesh.apply_transform(geom.get_local_pose().to_transformation_matrix()) + meshes.append(mesh) + return meshes + + +def get_render_body_meshes(visual_body: sapien.render.RenderBodyComponent): + meshes = [] + for render_shape in visual_body.render_shapes: + meshes += get_render_shape_meshes(render_shape) + return meshes + + +def get_render_shape_meshes(render_shape: sapien.render.RenderShape): + meshes = [] + if type(render_shape) == sapien.render.RenderShapeTriangleMesh: + for part in render_shape.parts: + vertices = part.vertices * render_shape.scale # [n, 3] + faces = part.triangles + # faces = render_shape.mesh.indices.reshape(-1, 3) # [m * 3] + mesh = trimesh.Trimesh(vertices=vertices, faces=faces) + mesh.apply_transform(render_shape.local_pose.to_transformation_matrix()) + meshes.append(mesh) + return meshes + + +def get_actor_visual_meshes(actor: sapien.Entity): + """Get actor (visual) meshes in the actor frame.""" + meshes = [] + comp = actor.find_component_by_type(sapien.render.RenderBodyComponent) + if comp is not None: + meshes.extend(get_render_body_meshes(comp)) + return meshes + + +def merge_meshes(meshes: List[trimesh.Trimesh]): + n, vs, fs = 0, [], [] + for mesh in meshes: + v, f = mesh.vertices, mesh.faces + vs.append(v) + fs.append(f + n) + n = n + v.shape[0] + if n: + return trimesh.Trimesh(np.vstack(vs), np.vstack(fs)) + else: + return None + + +def get_component_mesh(component: physx.PhysxRigidBaseComponent, to_world_frame=True): + mesh = merge_meshes(get_component_meshes(component)) + if mesh is None: + return None + if to_world_frame: + T = component.pose.to_transformation_matrix() + mesh.apply_transform(T) + return mesh + + +def get_actor_visual_mesh(actor: sapien.Entity): + mesh = merge_meshes(get_actor_visual_meshes(actor)) + if mesh is None: + return None + return mesh + + +def get_articulation_meshes( + articulation: physx.PhysxArticulation, exclude_link_names=() +): + """Get link meshes in the world frame.""" + meshes = [] + for link in articulation.get_links(): + if link.name in exclude_link_names: + continue + mesh = get_component_mesh(link, True) + if mesh is None: + continue + meshes.append(mesh) + return meshes diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d1209205d93df3de2b4bbd6dff8fd530bd72dc2e --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__init__.py @@ -0,0 +1 @@ +from .scene_builder import SceneBuilder diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c36f34bef3012302426b227295a25e8b662f1831 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__pycache__/registration.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__pycache__/registration.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0a3d7c0274eb91cb9c62f17294f2e2cdeac0cde6 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__pycache__/registration.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__pycache__/scene_builder.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__pycache__/scene_builder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6a6a1decba7e28b8f3d7f5295e88da82917cf904 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__pycache__/scene_builder.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75868365b83c07f2823d57df495492859dc8ef7f --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__init__.py @@ -0,0 +1,6 @@ +from .variants import ( + ArchitecTHORSceneBuilder, + ProcTHORSceneBuilder, + RoboTHORSceneBuilder, + iTHORSceneBuilder, +) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e5521ab34ca7c359c5fede3f39f95ffce96634f Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/constants.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/constants.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f3608df48d55083bb31ff6dd48d3ed0b30ef776 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/constants.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/scene_builder.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/scene_builder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea792b1678a5e240e902fac4f79e06bd8b47ef46 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/scene_builder.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/variants.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/variants.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f2986b495f1a4afc7bf2c26fdba04fc251bb919 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__pycache__/variants.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/constants.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..53f33a81f4d143cc8d7bcdcf7a3c8e1e8f38018d --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/constants.py @@ -0,0 +1,171 @@ +import json +import os.path as osp +from dataclasses import dataclass +from pathlib import Path +from typing import Dict + +from mani_skill import ASSET_DIR + + +@dataclass +class AI2BuildConfig: + config_file: str + source: str + spawn_pos_file: str = None + + +@dataclass +class SceneDataset: + metadata_path: str + dataset_path: str + + +def load_ai2thor_metadata(): + with open( + str( + Path(ASSET_DIR) + / "scene_datasets/ai2thor/ai2thor-hab/configs/object_semantic_id_mapping.json" + ), + "r", + ) as f: + OBJECT_SEMANTIC_ID_MAPPING = json.load(f) + SEMANTIC_ID_OBJECT_MAPPING = dict() + for k in OBJECT_SEMANTIC_ID_MAPPING: + SEMANTIC_ID_OBJECT_MAPPING[OBJECT_SEMANTIC_ID_MAPPING[k]] = k + MOVEABLE_OBJECT_IDS = [ + "Apple", + "AppleSliced", + "Tomato", + "TomatoSliced", + "Bread", + "BreadSliced", + "Chair", + "HousePlant", + "Pot", + "Pan", + "Knife", + "Fork", + "Spoon", + "Bowl", + "Toaster", + "CoffeeMachine", + "Egg", + "Lettuce", + "Potato", + "Mug", + "Plate", + "GarbageCan", + "Omelette", + "EggShell", + "EggCracked", + "Container", + "Cup", + "ButterKnife", + "PotatoSliced", + "MugFilled", + "BowlFilled", + "LettuceSliced", + "ContainerFull", + "BowlDirty", + "Sandwich", + "TissueBox", + "VacuumCleaner", + "WateringCan", + "Laptop", + "RemoteControl", + "Box", + "Newspaper", + "KeyChain", + "Dirt", + "CellPhone", + "CreditCard", + "Cloth", + "Candle", + "Plunger", + "ToiletPaper", + "ToiletPaperHanger", + "SoapBottle", + "SoapBottleFilled", + "SoapBar", + "ShowerDoor", + "SprayBottle", + "ScrubBrush", + "ToiletPaperRoll", + "Lamp", + "Book", + "SportsEquipment", + "Pen", + "Pencil", + "Watch", + "MiscTableObject", + "BaseballBat", + "BasketBall", + "Boots", + "Bottle", + "DishSponge", + "FloorLamp", + "Kettle", + "Lighter", + "PanLid", + "PaperTowelRoll", + "PepperShaker", + "PotLid", + "SaltShaker", + "Safe", + "SmallMirror", + "Spatula", + "TeddyBear", + "TennisRacket", + "Tissue", + "Vase", + "MassObjectSpawner", + "MassScale", + "Footstool", + "Pillow", + "Cart", + "DeskLamp", + "CD", + "Poster", + "HandTowel", + "Ladle", + "WineBottle", + "AluminumFoil", + "DogBed", + "Dumbbell", + "TableTopDecor", + "RoomDecor", + "Stool", + "GarbageBag", + "Desktop", + "TargetCircle", + ] + return OBJECT_SEMANTIC_ID_MAPPING, SEMANTIC_ID_OBJECT_MAPPING, MOVEABLE_OBJECT_IDS + + +# This maps a scene set e.g. ProcTHOR to an adapter, metadata, and where the scenes are saved to. The adapter is a class that can load the scene set +SCENE_SOURCE_TO_DATASET: Dict[str, SceneDataset] = { + "ProcTHOR": SceneDataset( + metadata_path="ProcTHOR.json", + dataset_path=osp.join( + ASSET_DIR, "scene_datasets/ai2thor/ai2thor-hab/configs/scenes/ProcTHOR" + ), + ), + "ArchitecTHOR": SceneDataset( + metadata_path="ArchitecTHOR.json", + dataset_path=osp.join( + ASSET_DIR, "scene_datasets/ai2thor/ai2thor-hab/configs/scenes/ArchitecTHOR" + ), + ), + "iTHOR": SceneDataset( + metadata_path="iTHOR.json", + dataset_path=osp.join( + ASSET_DIR, "scene_datasets/ai2thor/ai2thor-hab/configs/scenes/iTHOR" + ), + ), + "RoboTHOR": SceneDataset( + metadata_path="RoboTHOR.json", + dataset_path=osp.join( + ASSET_DIR, "scene_datasets/ai2thor/ai2thor-hab/configs/scenes/RoboTHOR" + ), + ), +} diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/ArchitecTHOR.json b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/ArchitecTHOR.json new file mode 100644 index 0000000000000000000000000000000000000000..6bbefaed09c217e2ef63f61f1e6c6e3c31495a25 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/ArchitecTHOR.json @@ -0,0 +1,14 @@ +{ + "scenes": [ + "./ArchitecTHOR-Test-03.scene_instance.json", + "./ArchitecTHOR-Val-02.scene_instance.json", + "./ArchitecTHOR-Val-01.scene_instance.json", + "./ArchitecTHOR-Test-02.scene_instance.json", + "./ArchitecTHOR-Val-04.scene_instance.json", + "./ArchitecTHOR-Val-03.scene_instance.json", + "./ArchitecTHOR-Val-00.scene_instance.json", + "./ArchitecTHOR-Test-01.scene_instance.json", + "./ArchitecTHOR-Test-04.scene_instance.json", + "./ArchitecTHOR-Test-00.scene_instance.json" + ] +} \ No newline at end of file diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/ProcTHOR.json b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/ProcTHOR.json new file mode 100644 index 0000000000000000000000000000000000000000..35eaf6008eb9884bf82ea5b79e3d336228dedb3b --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/ProcTHOR.json @@ -0,0 +1,12005 @@ +{ + "scenes": [ + "./2/ProcTHOR-Train-293.scene_instance.json", + "./2/ProcTHOR-Train-854.scene_instance.json", + "./2/ProcTHOR-Train-650.scene_instance.json", + "./2/ProcTHOR-Train-616.scene_instance.json", + "./2/ProcTHOR-Train-147.scene_instance.json", + "./2/ProcTHOR-Train-459.scene_instance.json", + "./2/ProcTHOR-Train-403.scene_instance.json", + "./2/ProcTHOR-Train-818.scene_instance.json", + "./2/ProcTHOR-Train-649.scene_instance.json", + "./2/ProcTHOR-Train-771.scene_instance.json", + "./2/ProcTHOR-Train-350.scene_instance.json", + "./2/ProcTHOR-Train-682.scene_instance.json", + "./2/ProcTHOR-Train-373.scene_instance.json", + "./2/ProcTHOR-Train-436.scene_instance.json", + "./2/ProcTHOR-Train-623.scene_instance.json", + "./2/ProcTHOR-Train-160.scene_instance.json", + "./2/ProcTHOR-Train-982.scene_instance.json", + "./2/ProcTHOR-Train-234.scene_instance.json", + "./2/ProcTHOR-Train-10.scene_instance.json", + "./2/ProcTHOR-Train-597.scene_instance.json", + "./2/ProcTHOR-Train-787.scene_instance.json", + "./2/ProcTHOR-Train-278.scene_instance.json", + "./2/ProcTHOR-Train-264.scene_instance.json", + "./2/ProcTHOR-Train-13.scene_instance.json", + "./2/ProcTHOR-Train-797.scene_instance.json", + "./2/ProcTHOR-Train-551.scene_instance.json", + "./2/ProcTHOR-Train-998.scene_instance.json", + "./2/ProcTHOR-Train-536.scene_instance.json", + "./2/ProcTHOR-Train-657.scene_instance.json", + "./2/ProcTHOR-Train-217.scene_instance.json", + "./2/ProcTHOR-Train-521.scene_instance.json", + "./2/ProcTHOR-Train-952.scene_instance.json", + "./2/ProcTHOR-Train-398.scene_instance.json", + "./2/ProcTHOR-Train-509.scene_instance.json", + "./2/ProcTHOR-Train-694.scene_instance.json", + "./2/ProcTHOR-Train-190.scene_instance.json", + "./2/ProcTHOR-Train-378.scene_instance.json", + "./2/ProcTHOR-Train-938.scene_instance.json", + "./2/ProcTHOR-Train-974.scene_instance.json", + "./2/ProcTHOR-Train-22.scene_instance.json", + "./2/ProcTHOR-Train-667.scene_instance.json", + "./2/ProcTHOR-Train-939.scene_instance.json", + "./2/ProcTHOR-Train-414.scene_instance.json", + "./2/ProcTHOR-Train-299.scene_instance.json", + "./2/ProcTHOR-Train-672.scene_instance.json", + "./2/ProcTHOR-Train-864.scene_instance.json", + "./2/ProcTHOR-Train-779.scene_instance.json", + "./2/ProcTHOR-Train-904.scene_instance.json", + "./2/ProcTHOR-Train-888.scene_instance.json", + "./2/ProcTHOR-Train-798.scene_instance.json", + "./2/ProcTHOR-Train-831.scene_instance.json", + "./2/ProcTHOR-Train-296.scene_instance.json", + "./2/ProcTHOR-Train-527.scene_instance.json", + "./2/ProcTHOR-Train-613.scene_instance.json", + "./2/ProcTHOR-Train-720.scene_instance.json", + "./2/ProcTHOR-Train-915.scene_instance.json", + "./2/ProcTHOR-Train-41.scene_instance.json", + "./2/ProcTHOR-Train-287.scene_instance.json", + "./2/ProcTHOR-Train-594.scene_instance.json", + "./2/ProcTHOR-Train-690.scene_instance.json", + "./2/ProcTHOR-Train-428.scene_instance.json", + "./2/ProcTHOR-Train-302.scene_instance.json", + "./2/ProcTHOR-Train-985.scene_instance.json", + "./2/ProcTHOR-Train-786.scene_instance.json", + "./2/ProcTHOR-Train-376.scene_instance.json", + "./2/ProcTHOR-Train-418.scene_instance.json", + "./2/ProcTHOR-Train-227.scene_instance.json", + "./2/ProcTHOR-Train-468.scene_instance.json", + "./2/ProcTHOR-Train-295.scene_instance.json", + "./2/ProcTHOR-Train-201.scene_instance.json", + "./2/ProcTHOR-Train-634.scene_instance.json", + "./2/ProcTHOR-Train-456.scene_instance.json", + "./2/ProcTHOR-Train-405.scene_instance.json", + "./2/ProcTHOR-Train-263.scene_instance.json", + "./2/ProcTHOR-Train-267.scene_instance.json", + "./2/ProcTHOR-Train-122.scene_instance.json", + "./2/ProcTHOR-Train-593.scene_instance.json", + "./2/ProcTHOR-Train-614.scene_instance.json", + "./2/ProcTHOR-Train-94.scene_instance.json", + "./2/ProcTHOR-Train-83.scene_instance.json", + "./2/ProcTHOR-Train-537.scene_instance.json", + "./2/ProcTHOR-Train-834.scene_instance.json", + "./2/ProcTHOR-Train-230.scene_instance.json", + "./2/ProcTHOR-Train-377.scene_instance.json", + "./2/ProcTHOR-Train-342.scene_instance.json", + "./2/ProcTHOR-Train-662.scene_instance.json", + "./2/ProcTHOR-Train-916.scene_instance.json", + "./2/ProcTHOR-Train-174.scene_instance.json", + "./2/ProcTHOR-Train-951.scene_instance.json", + "./2/ProcTHOR-Train-203.scene_instance.json", + "./2/ProcTHOR-Train-452.scene_instance.json", + "./2/ProcTHOR-Train-391.scene_instance.json", + "./2/ProcTHOR-Train-851.scene_instance.json", + "./2/ProcTHOR-Train-366.scene_instance.json", + "./2/ProcTHOR-Train-727.scene_instance.json", + "./2/ProcTHOR-Train-870.scene_instance.json", + "./2/ProcTHOR-Train-345.scene_instance.json", + "./2/ProcTHOR-Train-898.scene_instance.json", + "./2/ProcTHOR-Train-380.scene_instance.json", + "./2/ProcTHOR-Train-504.scene_instance.json", + "./2/ProcTHOR-Train-837.scene_instance.json", + "./2/ProcTHOR-Train-298.scene_instance.json", + "./2/ProcTHOR-Train-933.scene_instance.json", + "./2/ProcTHOR-Train-562.scene_instance.json", + "./2/ProcTHOR-Train-580.scene_instance.json", + "./2/ProcTHOR-Train-117.scene_instance.json", + "./2/ProcTHOR-Train-622.scene_instance.json", + "./2/ProcTHOR-Train-483.scene_instance.json", + "./2/ProcTHOR-Train-261.scene_instance.json", + "./2/ProcTHOR-Train-615.scene_instance.json", + "./2/ProcTHOR-Train-716.scene_instance.json", + "./2/ProcTHOR-Train-782.scene_instance.json", + "./2/ProcTHOR-Train-814.scene_instance.json", + "./2/ProcTHOR-Train-922.scene_instance.json", + "./2/ProcTHOR-Train-370.scene_instance.json", + "./2/ProcTHOR-Train-612.scene_instance.json", + "./2/ProcTHOR-Train-601.scene_instance.json", + "./2/ProcTHOR-Train-343.scene_instance.json", + "./2/ProcTHOR-Train-971.scene_instance.json", + "./2/ProcTHOR-Train-184.scene_instance.json", + "./2/ProcTHOR-Train-443.scene_instance.json", + "./2/ProcTHOR-Train-207.scene_instance.json", + "./2/ProcTHOR-Train-369.scene_instance.json", + "./2/ProcTHOR-Train-53.scene_instance.json", + "./2/ProcTHOR-Train-327.scene_instance.json", + "./2/ProcTHOR-Train-806.scene_instance.json", + "./2/ProcTHOR-Train-619.scene_instance.json", + "./2/ProcTHOR-Train-292.scene_instance.json", + "./2/ProcTHOR-Train-273.scene_instance.json", + "./2/ProcTHOR-Train-294.scene_instance.json", + "./2/ProcTHOR-Train-889.scene_instance.json", + "./2/ProcTHOR-Train-653.scene_instance.json", + "./2/ProcTHOR-Train-307.scene_instance.json", + "./2/ProcTHOR-Train-478.scene_instance.json", + "./2/ProcTHOR-Train-525.scene_instance.json", + "./2/ProcTHOR-Train-25.scene_instance.json", + "./2/ProcTHOR-Train-968.scene_instance.json", + "./2/ProcTHOR-Train-218.scene_instance.json", + "./2/ProcTHOR-Train-486.scene_instance.json", + "./2/ProcTHOR-Train-463.scene_instance.json", + "./2/ProcTHOR-Train-424.scene_instance.json", + "./2/ProcTHOR-Train-918.scene_instance.json", + "./2/ProcTHOR-Train-351.scene_instance.json", + "./2/ProcTHOR-Train-640.scene_instance.json", + "./2/ProcTHOR-Train-848.scene_instance.json", + "./2/ProcTHOR-Train-877.scene_instance.json", + "./2/ProcTHOR-Train-954.scene_instance.json", + "./2/ProcTHOR-Train-621.scene_instance.json", + "./2/ProcTHOR-Train-645.scene_instance.json", + "./2/ProcTHOR-Train-931.scene_instance.json", + "./2/ProcTHOR-Train-567.scene_instance.json", + "./2/ProcTHOR-Train-715.scene_instance.json", + "./2/ProcTHOR-Train-909.scene_instance.json", + "./2/ProcTHOR-Train-765.scene_instance.json", + "./2/ProcTHOR-Train-215.scene_instance.json", + "./2/ProcTHOR-Train-47.scene_instance.json", + "./2/ProcTHOR-Train-879.scene_instance.json", + "./2/ProcTHOR-Train-44.scene_instance.json", + "./2/ProcTHOR-Train-620.scene_instance.json", + "./2/ProcTHOR-Train-702.scene_instance.json", + "./2/ProcTHOR-Train-745.scene_instance.json", + "./2/ProcTHOR-Train-762.scene_instance.json", + "./2/ProcTHOR-Train-335.scene_instance.json", + "./2/ProcTHOR-Train-348.scene_instance.json", + "./2/ProcTHOR-Train-552.scene_instance.json", + "./2/ProcTHOR-Train-228.scene_instance.json", + "./2/ProcTHOR-Train-631.scene_instance.json", + "./2/ProcTHOR-Train-77.scene_instance.json", + "./2/ProcTHOR-Train-136.scene_instance.json", + "./2/ProcTHOR-Train-357.scene_instance.json", + "./2/ProcTHOR-Train-605.scene_instance.json", + "./2/ProcTHOR-Train-415.scene_instance.json", + "./2/ProcTHOR-Train-387.scene_instance.json", + "./2/ProcTHOR-Train-752.scene_instance.json", + "./2/ProcTHOR-Train-735.scene_instance.json", + "./2/ProcTHOR-Train-596.scene_instance.json", + "./2/ProcTHOR-Train-712.scene_instance.json", + "./2/ProcTHOR-Train-763.scene_instance.json", + "./2/ProcTHOR-Train-454.scene_instance.json", + "./2/ProcTHOR-Train-942.scene_instance.json", + "./2/ProcTHOR-Train-224.scene_instance.json", + "./2/ProcTHOR-Train-654.scene_instance.json", + "./2/ProcTHOR-Train-432.scene_instance.json", + "./2/ProcTHOR-Train-499.scene_instance.json", + "./2/ProcTHOR-Train-341.scene_instance.json", + "./2/ProcTHOR-Train-785.scene_instance.json", + "./2/ProcTHOR-Train-799.scene_instance.json", + "./2/ProcTHOR-Train-568.scene_instance.json", + "./2/ProcTHOR-Train-305.scene_instance.json", + "./2/ProcTHOR-Train-27.scene_instance.json", + "./2/ProcTHOR-Train-684.scene_instance.json", + "./2/ProcTHOR-Train-955.scene_instance.json", + "./2/ProcTHOR-Train-947.scene_instance.json", + "./2/ProcTHOR-Train-710.scene_instance.json", + "./2/ProcTHOR-Train-859.scene_instance.json", + "./2/ProcTHOR-Train-927.scene_instance.json", + "./2/ProcTHOR-Train-331.scene_instance.json", + "./2/ProcTHOR-Train-330.scene_instance.json", + "./2/ProcTHOR-Train-637.scene_instance.json", + "./2/ProcTHOR-Train-508.scene_instance.json", + "./2/ProcTHOR-Train-490.scene_instance.json", + "./2/ProcTHOR-Train-79.scene_instance.json", + "./2/ProcTHOR-Train-75.scene_instance.json", + "./2/ProcTHOR-Train-538.scene_instance.json", + "./2/ProcTHOR-Train-23.scene_instance.json", + "./2/ProcTHOR-Train-558.scene_instance.json", + "./2/ProcTHOR-Train-413.scene_instance.json", + "./2/ProcTHOR-Train-810.scene_instance.json", + "./2/ProcTHOR-Train-544.scene_instance.json", + "./2/ProcTHOR-Train-173.scene_instance.json", + "./2/ProcTHOR-Train-372.scene_instance.json", + "./2/ProcTHOR-Train-932.scene_instance.json", + "./2/ProcTHOR-Train-326.scene_instance.json", + "./2/ProcTHOR-Train-354.scene_instance.json", + "./2/ProcTHOR-Train-635.scene_instance.json", + "./2/ProcTHOR-Train-132.scene_instance.json", + "./2/ProcTHOR-Train-934.scene_instance.json", + "./2/ProcTHOR-Train-115.scene_instance.json", + "./2/ProcTHOR-Train-306.scene_instance.json", + "./2/ProcTHOR-Train-475.scene_instance.json", + "./2/ProcTHOR-Train-565.scene_instance.json", + "./2/ProcTHOR-Train-553.scene_instance.json", + "./2/ProcTHOR-Train-109.scene_instance.json", + "./2/ProcTHOR-Train-586.scene_instance.json", + "./2/ProcTHOR-Train-803.scene_instance.json", + "./2/ProcTHOR-Train-924.scene_instance.json", + "./2/ProcTHOR-Train-701.scene_instance.json", + "./2/ProcTHOR-Train-300.scene_instance.json", + "./2/ProcTHOR-Train-180.scene_instance.json", + "./2/ProcTHOR-Train-880.scene_instance.json", + "./2/ProcTHOR-Train-426.scene_instance.json", + "./2/ProcTHOR-Train-338.scene_instance.json", + "./2/ProcTHOR-Train-717.scene_instance.json", + "./2/ProcTHOR-Train-676.scene_instance.json", + "./2/ProcTHOR-Train-325.scene_instance.json", + "./2/ProcTHOR-Train-911.scene_instance.json", + "./2/ProcTHOR-Train-466.scene_instance.json", + "./2/ProcTHOR-Train-356.scene_instance.json", + "./2/ProcTHOR-Train-383.scene_instance.json", + "./2/ProcTHOR-Train-223.scene_instance.json", + "./2/ProcTHOR-Train-935.scene_instance.json", + "./2/ProcTHOR-Train-576.scene_instance.json", + "./2/ProcTHOR-Train-346.scene_instance.json", + "./2/ProcTHOR-Train-39.scene_instance.json", + "./2/ProcTHOR-Train-138.scene_instance.json", + "./2/ProcTHOR-Train-850.scene_instance.json", + "./2/ProcTHOR-Train-989.scene_instance.json", + "./2/ProcTHOR-Train-805.scene_instance.json", + "./2/ProcTHOR-Train-840.scene_instance.json", + "./2/ProcTHOR-Train-400.scene_instance.json", + "./2/ProcTHOR-Train-423.scene_instance.json", + "./2/ProcTHOR-Train-770.scene_instance.json", + "./2/ProcTHOR-Train-238.scene_instance.json", + "./2/ProcTHOR-Train-233.scene_instance.json", + "./2/ProcTHOR-Train-402.scene_instance.json", + "./2/ProcTHOR-Train-219.scene_instance.json", + "./2/ProcTHOR-Train-919.scene_instance.json", + "./2/ProcTHOR-Train-994.scene_instance.json", + "./2/ProcTHOR-Train-903.scene_instance.json", + "./2/ProcTHOR-Train-61.scene_instance.json", + "./2/ProcTHOR-Train-686.scene_instance.json", + "./2/ProcTHOR-Train-322.scene_instance.json", + "./2/ProcTHOR-Train-733.scene_instance.json", + "./2/ProcTHOR-Train-142.scene_instance.json", + "./2/ProcTHOR-Train-311.scene_instance.json", + "./2/ProcTHOR-Train-679.scene_instance.json", + "./2/ProcTHOR-Train-192.scene_instance.json", + "./2/ProcTHOR-Train-981.scene_instance.json", + "./2/ProcTHOR-Train-991.scene_instance.json", + "./2/ProcTHOR-Train-95.scene_instance.json", + "./2/ProcTHOR-Train-979.scene_instance.json", + "./2/ProcTHOR-Train-936.scene_instance.json", + "./2/ProcTHOR-Train-896.scene_instance.json", + "./2/ProcTHOR-Train-353.scene_instance.json", + "./2/ProcTHOR-Train-401.scene_instance.json", + "./2/ProcTHOR-Train-336.scene_instance.json", + "./2/ProcTHOR-Train-255.scene_instance.json", + "./2/ProcTHOR-Train-333.scene_instance.json", + "./2/ProcTHOR-Train-152.scene_instance.json", + "./2/ProcTHOR-Train-252.scene_instance.json", + "./2/ProcTHOR-Train-728.scene_instance.json", + "./2/ProcTHOR-Train-917.scene_instance.json", + "./2/ProcTHOR-Train-966.scene_instance.json", + "./2/ProcTHOR-Train-897.scene_instance.json", + "./2/ProcTHOR-Train-439.scene_instance.json", + "./2/ProcTHOR-Train-6.scene_instance.json", + "./2/ProcTHOR-Train-691.scene_instance.json", + "./2/ProcTHOR-Train-51.scene_instance.json", + "./2/ProcTHOR-Train-713.scene_instance.json", + "./2/ProcTHOR-Train-315.scene_instance.json", + "./2/ProcTHOR-Train-162.scene_instance.json", + "./2/ProcTHOR-Train-226.scene_instance.json", + "./2/ProcTHOR-Train-821.scene_instance.json", + "./2/ProcTHOR-Train-185.scene_instance.json", + "./2/ProcTHOR-Train-112.scene_instance.json", + "./2/ProcTHOR-Train-912.scene_instance.json", + "./2/ProcTHOR-Train-38.scene_instance.json", + "./2/ProcTHOR-Train-464.scene_instance.json", + "./2/ProcTHOR-Train-578.scene_instance.json", + "./2/ProcTHOR-Train-92.scene_instance.json", + "./2/ProcTHOR-Train-388.scene_instance.json", + "./2/ProcTHOR-Train-419.scene_instance.json", + "./2/ProcTHOR-Train-461.scene_instance.json", + "./2/ProcTHOR-Train-355.scene_instance.json", + "./2/ProcTHOR-Train-826.scene_instance.json", + "./2/ProcTHOR-Train-592.scene_instance.json", + "./2/ProcTHOR-Train-795.scene_instance.json", + "./2/ProcTHOR-Train-29.scene_instance.json", + "./2/ProcTHOR-Train-714.scene_instance.json", + "./2/ProcTHOR-Train-595.scene_instance.json", + "./2/ProcTHOR-Train-608.scene_instance.json", + "./2/ProcTHOR-Train-202.scene_instance.json", + "./2/ProcTHOR-Train-8.scene_instance.json", + "./2/ProcTHOR-Train-699.scene_instance.json", + "./2/ProcTHOR-Train-352.scene_instance.json", + "./2/ProcTHOR-Train-564.scene_instance.json", + "./2/ProcTHOR-Train-472.scene_instance.json", + "./2/ProcTHOR-Train-751.scene_instance.json", + "./2/ProcTHOR-Train-663.scene_instance.json", + "./2/ProcTHOR-Train-48.scene_instance.json", + "./2/ProcTHOR-Train-119.scene_instance.json", + "./2/ProcTHOR-Train-529.scene_instance.json", + "./2/ProcTHOR-Train-411.scene_instance.json", + "./2/ProcTHOR-Train-861.scene_instance.json", + "./2/ProcTHOR-Train-437.scene_instance.json", + "./2/ProcTHOR-Train-60.scene_instance.json", + "./2/ProcTHOR-Train-902.scene_instance.json", + "./2/ProcTHOR-Train-885.scene_instance.json", + "./2/ProcTHOR-Train-425.scene_instance.json", + "./2/ProcTHOR-Train-617.scene_instance.json", + "./2/ProcTHOR-Train-26.scene_instance.json", + "./2/ProcTHOR-Train-229.scene_instance.json", + "./2/ProcTHOR-Train-440.scene_instance.json", + "./2/ProcTHOR-Train-24.scene_instance.json", + "./2/ProcTHOR-Train-85.scene_instance.json", + "./2/ProcTHOR-Train-698.scene_instance.json", + "./2/ProcTHOR-Train-421.scene_instance.json", + "./2/ProcTHOR-Train-243.scene_instance.json", + "./2/ProcTHOR-Train-205.scene_instance.json", + "./2/ProcTHOR-Train-964.scene_instance.json", + "./2/ProcTHOR-Train-881.scene_instance.json", + "./2/ProcTHOR-Train-900.scene_instance.json", + "./2/ProcTHOR-Train-731.scene_instance.json", + "./2/ProcTHOR-Train-467.scene_instance.json", + "./2/ProcTHOR-Train-975.scene_instance.json", + "./2/ProcTHOR-Train-829.scene_instance.json", + "./2/ProcTHOR-Train-577.scene_instance.json", + "./2/ProcTHOR-Train-875.scene_instance.json", + "./2/ProcTHOR-Train-960.scene_instance.json", + "./2/ProcTHOR-Train-17.scene_instance.json", + "./2/ProcTHOR-Train-216.scene_instance.json", + "./2/ProcTHOR-Train-111.scene_instance.json", + "./2/ProcTHOR-Train-582.scene_instance.json", + "./2/ProcTHOR-Train-435.scene_instance.json", + "./2/ProcTHOR-Train-288.scene_instance.json", + "./2/ProcTHOR-Train-107.scene_instance.json", + "./2/ProcTHOR-Train-572.scene_instance.json", + "./2/ProcTHOR-Train-953.scene_instance.json", + "./2/ProcTHOR-Train-890.scene_instance.json", + "./2/ProcTHOR-Train-163.scene_instance.json", + "./2/ProcTHOR-Train-532.scene_instance.json", + "./2/ProcTHOR-Train-269.scene_instance.json", + "./2/ProcTHOR-Train-784.scene_instance.json", + "./2/ProcTHOR-Train-883.scene_instance.json", + "./2/ProcTHOR-Train-603.scene_instance.json", + "./2/ProcTHOR-Train-678.scene_instance.json", + "./2/ProcTHOR-Train-220.scene_instance.json", + "./2/ProcTHOR-Train-928.scene_instance.json", + "./2/ProcTHOR-Train-772.scene_instance.json", + "./2/ProcTHOR-Train-194.scene_instance.json", + "./2/ProcTHOR-Train-638.scene_instance.json", + "./2/ProcTHOR-Train-167.scene_instance.json", + "./2/ProcTHOR-Train-165.scene_instance.json", + "./2/ProcTHOR-Train-134.scene_instance.json", + "./2/ProcTHOR-Train-140.scene_instance.json", + "./2/ProcTHOR-Train-427.scene_instance.json", + "./2/ProcTHOR-Train-749.scene_instance.json", + "./2/ProcTHOR-Train-907.scene_instance.json", + "./2/ProcTHOR-Train-476.scene_instance.json", + "./2/ProcTHOR-Train-488.scene_instance.json", + "./2/ProcTHOR-Train-906.scene_instance.json", + "./2/ProcTHOR-Train-835.scene_instance.json", + "./2/ProcTHOR-Train-520.scene_instance.json", + "./2/ProcTHOR-Train-339.scene_instance.json", + "./2/ProcTHOR-Train-774.scene_instance.json", + "./2/ProcTHOR-Train-133.scene_instance.json", + "./2/ProcTHOR-Train-282.scene_instance.json", + "./2/ProcTHOR-Train-105.scene_instance.json", + "./2/ProcTHOR-Train-750.scene_instance.json", + "./2/ProcTHOR-Train-747.scene_instance.json", + "./2/ProcTHOR-Train-170.scene_instance.json", + "./2/ProcTHOR-Train-88.scene_instance.json", + "./2/ProcTHOR-Train-128.scene_instance.json", + "./2/ProcTHOR-Train-757.scene_instance.json", + "./2/ProcTHOR-Train-560.scene_instance.json", + "./2/ProcTHOR-Train-438.scene_instance.json", + "./2/ProcTHOR-Train-121.scene_instance.json", + "./2/ProcTHOR-Train-123.scene_instance.json", + "./2/ProcTHOR-Train-517.scene_instance.json", + "./2/ProcTHOR-Train-209.scene_instance.json", + "./2/ProcTHOR-Train-433.scene_instance.json", + "./2/ProcTHOR-Train-96.scene_instance.json", + "./2/ProcTHOR-Train-892.scene_instance.json", + "./2/ProcTHOR-Train-74.scene_instance.json", + "./2/ProcTHOR-Train-494.scene_instance.json", + "./2/ProcTHOR-Train-470.scene_instance.json", + "./2/ProcTHOR-Train-962.scene_instance.json", + "./2/ProcTHOR-Train-181.scene_instance.json", + "./2/ProcTHOR-Train-793.scene_instance.json", + "./2/ProcTHOR-Train-200.scene_instance.json", + "./2/ProcTHOR-Train-314.scene_instance.json", + "./2/ProcTHOR-Train-150.scene_instance.json", + "./2/ProcTHOR-Train-760.scene_instance.json", + "./2/ProcTHOR-Train-647.scene_instance.json", + "./2/ProcTHOR-Train-740.scene_instance.json", + "./2/ProcTHOR-Train-135.scene_instance.json", + "./2/ProcTHOR-Train-416.scene_instance.json", + "./2/ProcTHOR-Train-905.scene_instance.json", + "./2/ProcTHOR-Train-397.scene_instance.json", + "./2/ProcTHOR-Train-429.scene_instance.json", + "./2/ProcTHOR-Train-57.scene_instance.json", + "./2/ProcTHOR-Train-865.scene_instance.json", + "./2/ProcTHOR-Train-725.scene_instance.json", + "./2/ProcTHOR-Train-279.scene_instance.json", + "./2/ProcTHOR-Train-721.scene_instance.json", + "./2/ProcTHOR-Train-705.scene_instance.json", + "./2/ProcTHOR-Train-316.scene_instance.json", + "./2/ProcTHOR-Train-318.scene_instance.json", + "./2/ProcTHOR-Train-489.scene_instance.json", + "./2/ProcTHOR-Train-362.scene_instance.json", + "./2/ProcTHOR-Train-253.scene_instance.json", + "./2/ProcTHOR-Train-360.scene_instance.json", + "./2/ProcTHOR-Train-755.scene_instance.json", + "./2/ProcTHOR-Train-157.scene_instance.json", + "./2/ProcTHOR-Train-891.scene_instance.json", + "./2/ProcTHOR-Train-231.scene_instance.json", + "./2/ProcTHOR-Train-555.scene_instance.json", + "./2/ProcTHOR-Train-852.scene_instance.json", + "./2/ProcTHOR-Train-393.scene_instance.json", + "./2/ProcTHOR-Train-312.scene_instance.json", + "./2/ProcTHOR-Train-791.scene_instance.json", + "./2/ProcTHOR-Train-349.scene_instance.json", + "./2/ProcTHOR-Train-599.scene_instance.json", + "./2/ProcTHOR-Train-533.scene_instance.json", + "./2/ProcTHOR-Train-610.scene_instance.json", + "./2/ProcTHOR-Train-496.scene_instance.json", + "./2/ProcTHOR-Train-254.scene_instance.json", + "./2/ProcTHOR-Train-11.scene_instance.json", + "./2/ProcTHOR-Train-210.scene_instance.json", + "./2/ProcTHOR-Train-232.scene_instance.json", + "./2/ProcTHOR-Train-908.scene_instance.json", + "./2/ProcTHOR-Train-583.scene_instance.json", + "./2/ProcTHOR-Train-59.scene_instance.json", + "./2/ProcTHOR-Train-783.scene_instance.json", + "./2/ProcTHOR-Train-914.scene_instance.json", + "./2/ProcTHOR-Train-977.scene_instance.json", + "./2/ProcTHOR-Train-518.scene_instance.json", + "./2/ProcTHOR-Train-446.scene_instance.json", + "./2/ProcTHOR-Train-2.scene_instance.json", + "./2/ProcTHOR-Train-151.scene_instance.json", + "./2/ProcTHOR-Train-858.scene_instance.json", + "./2/ProcTHOR-Train-707.scene_instance.json", + "./2/ProcTHOR-Train-172.scene_instance.json", + "./2/ProcTHOR-Train-542.scene_instance.json", + "./2/ProcTHOR-Train-736.scene_instance.json", + "./2/ProcTHOR-Train-688.scene_instance.json", + "./2/ProcTHOR-Train-984.scene_instance.json", + "./2/ProcTHOR-Train-961.scene_instance.json", + "./2/ProcTHOR-Train-659.scene_instance.json", + "./2/ProcTHOR-Train-573.scene_instance.json", + "./2/ProcTHOR-Train-448.scene_instance.json", + "./2/ProcTHOR-Train-857.scene_instance.json", + "./2/ProcTHOR-Train-63.scene_instance.json", + "./2/ProcTHOR-Train-237.scene_instance.json", + "./2/ProcTHOR-Train-687.scene_instance.json", + "./2/ProcTHOR-Train-379.scene_instance.json", + "./2/ProcTHOR-Train-980.scene_instance.json", + "./2/ProcTHOR-Train-18.scene_instance.json", + "./2/ProcTHOR-Train-986.scene_instance.json", + "./2/ProcTHOR-Train-656.scene_instance.json", + "./2/ProcTHOR-Train-776.scene_instance.json", + "./2/ProcTHOR-Train-64.scene_instance.json", + "./2/ProcTHOR-Train-941.scene_instance.json", + "./2/ProcTHOR-Train-512.scene_instance.json", + "./2/ProcTHOR-Train-143.scene_instance.json", + "./2/ProcTHOR-Train-777.scene_instance.json", + "./2/ProcTHOR-Train-646.scene_instance.json", + "./2/ProcTHOR-Train-275.scene_instance.json", + "./2/ProcTHOR-Train-993.scene_instance.json", + "./2/ProcTHOR-Train-367.scene_instance.json", + "./2/ProcTHOR-Train-449.scene_instance.json", + "./2/ProcTHOR-Train-658.scene_instance.json", + "./2/ProcTHOR-Train-811.scene_instance.json", + "./2/ProcTHOR-Train-458.scene_instance.json", + "./2/ProcTHOR-Train-297.scene_instance.json", + "./2/ProcTHOR-Train-869.scene_instance.json", + "./2/ProcTHOR-Train-67.scene_instance.json", + "./2/ProcTHOR-Train-574.scene_instance.json", + "./2/ProcTHOR-Train-236.scene_instance.json", + "./2/ProcTHOR-Train-385.scene_instance.json", + "./2/ProcTHOR-Train-283.scene_instance.json", + "./2/ProcTHOR-Train-308.scene_instance.json", + "./2/ProcTHOR-Train-629.scene_instance.json", + "./2/ProcTHOR-Train-836.scene_instance.json", + "./2/ProcTHOR-Train-93.scene_instance.json", + "./2/ProcTHOR-Train-156.scene_instance.json", + "./2/ProcTHOR-Train-141.scene_instance.json", + "./2/ProcTHOR-Train-983.scene_instance.json", + "./2/ProcTHOR-Train-90.scene_instance.json", + "./2/ProcTHOR-Train-884.scene_instance.json", + "./2/ProcTHOR-Train-813.scene_instance.json", + "./2/ProcTHOR-Train-159.scene_instance.json", + "./2/ProcTHOR-Train-648.scene_instance.json", + "./2/ProcTHOR-Train-632.scene_instance.json", + "./2/ProcTHOR-Train-274.scene_instance.json", + "./2/ProcTHOR-Train-636.scene_instance.json", + "./2/ProcTHOR-Train-758.scene_instance.json", + "./2/ProcTHOR-Train-381.scene_instance.json", + "./2/ProcTHOR-Train-249.scene_instance.json", + "./2/ProcTHOR-Train-910.scene_instance.json", + "./2/ProcTHOR-Train-804.scene_instance.json", + "./2/ProcTHOR-Train-191.scene_instance.json", + "./2/ProcTHOR-Train-118.scene_instance.json", + "./2/ProcTHOR-Train-245.scene_instance.json", + "./2/ProcTHOR-Train-965.scene_instance.json", + "./2/ProcTHOR-Train-340.scene_instance.json", + "./2/ProcTHOR-Train-332.scene_instance.json", + "./2/ProcTHOR-Train-769.scene_instance.json", + "./2/ProcTHOR-Train-846.scene_instance.json", + "./2/ProcTHOR-Train-753.scene_instance.json", + "./2/ProcTHOR-Train-990.scene_instance.json", + "./2/ProcTHOR-Train-734.scene_instance.json", + "./2/ProcTHOR-Train-992.scene_instance.json", + "./2/ProcTHOR-Train-177.scene_instance.json", + "./2/ProcTHOR-Train-98.scene_instance.json", + "./2/ProcTHOR-Train-742.scene_instance.json", + "./2/ProcTHOR-Train-71.scene_instance.json", + "./2/ProcTHOR-Train-412.scene_instance.json", + "./2/ProcTHOR-Train-324.scene_instance.json", + "./2/ProcTHOR-Train-794.scene_instance.json", + "./2/ProcTHOR-Train-531.scene_instance.json", + "./2/ProcTHOR-Train-408.scene_instance.json", + "./2/ProcTHOR-Train-498.scene_instance.json", + "./2/ProcTHOR-Train-52.scene_instance.json", + "./2/ProcTHOR-Train-290.scene_instance.json", + "./2/ProcTHOR-Train-516.scene_instance.json", + "./2/ProcTHOR-Train-101.scene_instance.json", + "./2/ProcTHOR-Train-129.scene_instance.json", + "./2/ProcTHOR-Train-106.scene_instance.json", + "./2/ProcTHOR-Train-807.scene_instance.json", + "./2/ProcTHOR-Train-447.scene_instance.json", + "./2/ProcTHOR-Train-328.scene_instance.json", + "./2/ProcTHOR-Train-482.scene_instance.json", + "./2/ProcTHOR-Train-113.scene_instance.json", + "./2/ProcTHOR-Train-860.scene_instance.json", + "./2/ProcTHOR-Train-382.scene_instance.json", + "./2/ProcTHOR-Train-21.scene_instance.json", + "./2/ProcTHOR-Train-368.scene_instance.json", + "./2/ProcTHOR-Train-681.scene_instance.json", + "./2/ProcTHOR-Train-474.scene_instance.json", + "./2/ProcTHOR-Train-104.scene_instance.json", + "./2/ProcTHOR-Train-969.scene_instance.json", + "./2/ProcTHOR-Train-361.scene_instance.json", + "./2/ProcTHOR-Train-526.scene_instance.json", + "./2/ProcTHOR-Train-853.scene_instance.json", + "./2/ProcTHOR-Train-817.scene_instance.json", + "./2/ProcTHOR-Train-550.scene_instance.json", + "./2/ProcTHOR-Train-32.scene_instance.json", + "./2/ProcTHOR-Train-76.scene_instance.json", + "./2/ProcTHOR-Train-587.scene_instance.json", + "./2/ProcTHOR-Train-154.scene_instance.json", + "./2/ProcTHOR-Train-706.scene_instance.json", + "./2/ProcTHOR-Train-358.scene_instance.json", + "./2/ProcTHOR-Train-144.scene_instance.json", + "./2/ProcTHOR-Train-789.scene_instance.json", + "./2/ProcTHOR-Train-847.scene_instance.json", + "./2/ProcTHOR-Train-732.scene_instance.json", + "./2/ProcTHOR-Train-590.scene_instance.json", + "./2/ProcTHOR-Train-841.scene_instance.json", + "./2/ProcTHOR-Train-767.scene_instance.json", + "./2/ProcTHOR-Train-176.scene_instance.json", + "./2/ProcTHOR-Train-65.scene_instance.json", + "./2/ProcTHOR-Train-571.scene_instance.json", + "./2/ProcTHOR-Train-838.scene_instance.json", + "./2/ProcTHOR-Train-862.scene_instance.json", + "./2/ProcTHOR-Train-480.scene_instance.json", + "./2/ProcTHOR-Train-541.scene_instance.json", + "./2/ProcTHOR-Train-741.scene_instance.json", + "./2/ProcTHOR-Train-660.scene_instance.json", + "./2/ProcTHOR-Train-289.scene_instance.json", + "./2/ProcTHOR-Train-62.scene_instance.json", + "./2/ProcTHOR-Train-606.scene_instance.json", + "./2/ProcTHOR-Train-222.scene_instance.json", + "./2/ProcTHOR-Train-102.scene_instance.json", + "./2/ProcTHOR-Train-655.scene_instance.json", + "./2/ProcTHOR-Train-949.scene_instance.json", + "./2/ProcTHOR-Train-337.scene_instance.json", + "./2/ProcTHOR-Train-666.scene_instance.json", + "./2/ProcTHOR-Train-609.scene_instance.json", + "./2/ProcTHOR-Train-239.scene_instance.json", + "./2/ProcTHOR-Train-384.scene_instance.json", + "./2/ProcTHOR-Train-780.scene_instance.json", + "./2/ProcTHOR-Train-395.scene_instance.json", + "./2/ProcTHOR-Train-0.scene_instance.json", + "./2/ProcTHOR-Train-748.scene_instance.json", + "./2/ProcTHOR-Train-206.scene_instance.json", + "./2/ProcTHOR-Train-824.scene_instance.json", + "./2/ProcTHOR-Train-213.scene_instance.json", + "./2/ProcTHOR-Train-116.scene_instance.json", + "./2/ProcTHOR-Train-913.scene_instance.json", + "./2/ProcTHOR-Train-487.scene_instance.json", + "./2/ProcTHOR-Train-661.scene_instance.json", + "./2/ProcTHOR-Train-866.scene_instance.json", + "./2/ProcTHOR-Train-270.scene_instance.json", + "./2/ProcTHOR-Train-12.scene_instance.json", + "./2/ProcTHOR-Train-73.scene_instance.json", + "./2/ProcTHOR-Train-78.scene_instance.json", + "./2/ProcTHOR-Train-91.scene_instance.json", + "./2/ProcTHOR-Train-139.scene_instance.json", + "./2/ProcTHOR-Train-455.scene_instance.json", + "./2/ProcTHOR-Train-812.scene_instance.json", + "./2/ProcTHOR-Train-761.scene_instance.json", + "./2/ProcTHOR-Train-808.scene_instance.json", + "./2/ProcTHOR-Train-390.scene_instance.json", + "./2/ProcTHOR-Train-535.scene_instance.json", + "./2/ProcTHOR-Train-4.scene_instance.json", + "./2/ProcTHOR-Train-872.scene_instance.json", + "./2/ProcTHOR-Train-534.scene_instance.json", + "./2/ProcTHOR-Train-320.scene_instance.json", + "./2/ProcTHOR-Train-894.scene_instance.json", + "./2/ProcTHOR-Train-627.scene_instance.json", + "./2/ProcTHOR-Train-921.scene_instance.json", + "./2/ProcTHOR-Train-125.scene_instance.json", + "./2/ProcTHOR-Train-247.scene_instance.json", + "./2/ProcTHOR-Train-434.scene_instance.json", + "./2/ProcTHOR-Train-630.scene_instance.json", + "./2/ProcTHOR-Train-241.scene_instance.json", + "./2/ProcTHOR-Train-997.scene_instance.json", + "./2/ProcTHOR-Train-15.scene_instance.json", + "./2/ProcTHOR-Train-515.scene_instance.json", + "./2/ProcTHOR-Train-730.scene_instance.json", + "./2/ProcTHOR-Train-547.scene_instance.json", + "./2/ProcTHOR-Train-492.scene_instance.json", + "./2/ProcTHOR-Train-42.scene_instance.json", + "./2/ProcTHOR-Train-737.scene_instance.json", + "./2/ProcTHOR-Train-700.scene_instance.json", + "./2/ProcTHOR-Train-386.scene_instance.json", + "./2/ProcTHOR-Train-503.scene_instance.json", + "./2/ProcTHOR-Train-832.scene_instance.json", + "./2/ProcTHOR-Train-823.scene_instance.json", + "./2/ProcTHOR-Train-744.scene_instance.json", + "./2/ProcTHOR-Train-285.scene_instance.json", + "./2/ProcTHOR-Train-746.scene_instance.json", + "./2/ProcTHOR-Train-221.scene_instance.json", + "./2/ProcTHOR-Train-365.scene_instance.json", + "./2/ProcTHOR-Train-146.scene_instance.json", + "./2/ProcTHOR-Train-303.scene_instance.json", + "./2/ProcTHOR-Train-70.scene_instance.json", + "./2/ProcTHOR-Train-258.scene_instance.json", + "./2/ProcTHOR-Train-347.scene_instance.json", + "./2/ProcTHOR-Train-505.scene_instance.json", + "./2/ProcTHOR-Train-673.scene_instance.json", + "./2/ProcTHOR-Train-363.scene_instance.json", + "./2/ProcTHOR-Train-268.scene_instance.json", + "./2/ProcTHOR-Train-310.scene_instance.json", + "./2/ProcTHOR-Train-89.scene_instance.json", + "./2/ProcTHOR-Train-581.scene_instance.json", + "./2/ProcTHOR-Train-36.scene_instance.json", + "./2/ProcTHOR-Train-680.scene_instance.json", + "./2/ProcTHOR-Train-168.scene_instance.json", + "./2/ProcTHOR-Train-559.scene_instance.json", + "./2/ProcTHOR-Train-868.scene_instance.json", + "./2/ProcTHOR-Train-484.scene_instance.json", + "./2/ProcTHOR-Train-406.scene_instance.json", + "./2/ProcTHOR-Train-639.scene_instance.json", + "./2/ProcTHOR-Train-652.scene_instance.json", + "./2/ProcTHOR-Train-893.scene_instance.json", + "./2/ProcTHOR-Train-561.scene_instance.json", + "./2/ProcTHOR-Train-849.scene_instance.json", + "./2/ProcTHOR-Train-764.scene_instance.json", + "./2/ProcTHOR-Train-40.scene_instance.json", + "./2/ProcTHOR-Train-169.scene_instance.json", + "./2/ProcTHOR-Train-514.scene_instance.json", + "./2/ProcTHOR-Train-628.scene_instance.json", + "./2/ProcTHOR-Train-633.scene_instance.json", + "./2/ProcTHOR-Train-828.scene_instance.json", + "./2/ProcTHOR-Train-80.scene_instance.json", + "./2/ProcTHOR-Train-364.scene_instance.json", + "./2/ProcTHOR-Train-703.scene_instance.json", + "./2/ProcTHOR-Train-175.scene_instance.json", + "./2/ProcTHOR-Train-33.scene_instance.json", + "./2/ProcTHOR-Train-973.scene_instance.json", + "./2/ProcTHOR-Train-103.scene_instance.json", + "./2/ProcTHOR-Train-301.scene_instance.json", + "./2/ProcTHOR-Train-882.scene_instance.json", + "./2/ProcTHOR-Train-149.scene_instance.json", + "./2/ProcTHOR-Train-277.scene_instance.json", + "./2/ProcTHOR-Train-958.scene_instance.json", + "./2/ProcTHOR-Train-642.scene_instance.json", + "./2/ProcTHOR-Train-284.scene_instance.json", + "./2/ProcTHOR-Train-161.scene_instance.json", + "./2/ProcTHOR-Train-937.scene_instance.json", + "./2/ProcTHOR-Train-540.scene_instance.json", + "./2/ProcTHOR-Train-250.scene_instance.json", + "./2/ProcTHOR-Train-729.scene_instance.json", + "./2/ProcTHOR-Train-212.scene_instance.json", + "./2/ProcTHOR-Train-566.scene_instance.json", + "./2/ProcTHOR-Train-651.scene_instance.json", + "./2/ProcTHOR-Train-257.scene_instance.json", + "./2/ProcTHOR-Train-556.scene_instance.json", + "./2/ProcTHOR-Train-886.scene_instance.json", + "./2/ProcTHOR-Train-235.scene_instance.json", + "./2/ProcTHOR-Train-668.scene_instance.json", + "./2/ProcTHOR-Train-845.scene_instance.json", + "./2/ProcTHOR-Train-182.scene_instance.json", + "./2/ProcTHOR-Train-197.scene_instance.json", + "./2/ProcTHOR-Train-775.scene_instance.json", + "./2/ProcTHOR-Train-925.scene_instance.json", + "./2/ProcTHOR-Train-549.scene_instance.json", + "./2/ProcTHOR-Train-948.scene_instance.json", + "./2/ProcTHOR-Train-575.scene_instance.json", + "./2/ProcTHOR-Train-524.scene_instance.json", + "./2/ProcTHOR-Train-956.scene_instance.json", + "./2/ProcTHOR-Train-693.scene_instance.json", + "./2/ProcTHOR-Train-166.scene_instance.json", + "./2/ProcTHOR-Train-389.scene_instance.json", + "./2/ProcTHOR-Train-978.scene_instance.json", + "./2/ProcTHOR-Train-193.scene_instance.json", + "./2/ProcTHOR-Train-643.scene_instance.json", + "./2/ProcTHOR-Train-695.scene_instance.json", + "./2/ProcTHOR-Train-792.scene_instance.json", + "./2/ProcTHOR-Train-692.scene_instance.json", + "./2/ProcTHOR-Train-266.scene_instance.json", + "./2/ProcTHOR-Train-887.scene_instance.json", + "./2/ProcTHOR-Train-396.scene_instance.json", + "./2/ProcTHOR-Train-477.scene_instance.json", + "./2/ProcTHOR-Train-404.scene_instance.json", + "./2/ProcTHOR-Train-670.scene_instance.json", + "./2/ProcTHOR-Train-304.scene_instance.json", + "./2/ProcTHOR-Train-591.scene_instance.json", + "./2/ProcTHOR-Train-272.scene_instance.json", + "./2/ProcTHOR-Train-675.scene_instance.json", + "./2/ProcTHOR-Train-204.scene_instance.json", + "./2/ProcTHOR-Train-453.scene_instance.json", + "./2/ProcTHOR-Train-451.scene_instance.json", + "./2/ProcTHOR-Train-265.scene_instance.json", + "./2/ProcTHOR-Train-58.scene_instance.json", + "./2/ProcTHOR-Train-607.scene_instance.json", + "./2/ProcTHOR-Train-726.scene_instance.json", + "./2/ProcTHOR-Train-768.scene_instance.json", + "./2/ProcTHOR-Train-479.scene_instance.json", + "./2/ProcTHOR-Train-708.scene_instance.json", + "./2/ProcTHOR-Train-256.scene_instance.json", + "./2/ProcTHOR-Train-671.scene_instance.json", + "./2/ProcTHOR-Train-108.scene_instance.json", + "./2/ProcTHOR-Train-976.scene_instance.json", + "./2/ProcTHOR-Train-930.scene_instance.json", + "./2/ProcTHOR-Train-923.scene_instance.json", + "./2/ProcTHOR-Train-422.scene_instance.json", + "./2/ProcTHOR-Train-839.scene_instance.json", + "./2/ProcTHOR-Train-407.scene_instance.json", + "./2/ProcTHOR-Train-244.scene_instance.json", + "./2/ProcTHOR-Train-199.scene_instance.json", + "./2/ProcTHOR-Train-334.scene_instance.json", + "./2/ProcTHOR-Train-800.scene_instance.json", + "./2/ProcTHOR-Train-420.scene_instance.json", + "./2/ProcTHOR-Train-82.scene_instance.json", + "./2/ProcTHOR-Train-827.scene_instance.json", + "./2/ProcTHOR-Train-495.scene_instance.json", + "./2/ProcTHOR-Train-709.scene_instance.json", + "./2/ProcTHOR-Train-759.scene_instance.json", + "./2/ProcTHOR-Train-313.scene_instance.json", + "./2/ProcTHOR-Train-523.scene_instance.json", + "./2/ProcTHOR-Train-604.scene_instance.json", + "./2/ProcTHOR-Train-739.scene_instance.json", + "./2/ProcTHOR-Train-718.scene_instance.json", + "./2/ProcTHOR-Train-214.scene_instance.json", + "./2/ProcTHOR-Train-460.scene_instance.json", + "./2/ProcTHOR-Train-145.scene_instance.json", + "./2/ProcTHOR-Train-618.scene_instance.json", + "./2/ProcTHOR-Train-563.scene_instance.json", + "./2/ProcTHOR-Train-689.scene_instance.json", + "./2/ProcTHOR-Train-485.scene_instance.json", + "./2/ProcTHOR-Train-450.scene_instance.json", + "./2/ProcTHOR-Train-895.scene_instance.json", + "./2/ProcTHOR-Train-554.scene_instance.json", + "./2/ProcTHOR-Train-878.scene_instance.json", + "./2/ProcTHOR-Train-55.scene_instance.json", + "./2/ProcTHOR-Train-359.scene_instance.json", + "./2/ProcTHOR-Train-704.scene_instance.json", + "./2/ProcTHOR-Train-371.scene_instance.json", + "./2/ProcTHOR-Train-513.scene_instance.json", + "./2/ProcTHOR-Train-685.scene_instance.json", + "./2/ProcTHOR-Train-929.scene_instance.json", + "./2/ProcTHOR-Train-195.scene_instance.json", + "./2/ProcTHOR-Train-611.scene_instance.json", + "./2/ProcTHOR-Train-153.scene_instance.json", + "./2/ProcTHOR-Train-66.scene_instance.json", + "./2/ProcTHOR-Train-286.scene_instance.json", + "./2/ProcTHOR-Train-120.scene_instance.json", + "./2/ProcTHOR-Train-473.scene_instance.json", + "./2/ProcTHOR-Train-987.scene_instance.json", + "./2/ProcTHOR-Train-510.scene_instance.json", + "./2/ProcTHOR-Train-624.scene_instance.json", + "./2/ProcTHOR-Train-198.scene_instance.json", + "./2/ProcTHOR-Train-519.scene_instance.json", + "./2/ProcTHOR-Train-127.scene_instance.json", + "./2/ProcTHOR-Train-30.scene_instance.json", + "./2/ProcTHOR-Train-959.scene_instance.json", + "./2/ProcTHOR-Train-409.scene_instance.json", + "./2/ProcTHOR-Train-68.scene_instance.json", + "./2/ProcTHOR-Train-240.scene_instance.json", + "./2/ProcTHOR-Train-14.scene_instance.json", + "./2/ProcTHOR-Train-99.scene_instance.json", + "./2/ProcTHOR-Train-497.scene_instance.json", + "./2/ProcTHOR-Train-178.scene_instance.json", + "./2/ProcTHOR-Train-72.scene_instance.json", + "./2/ProcTHOR-Train-830.scene_instance.json", + "./2/ProcTHOR-Train-790.scene_instance.json", + "./2/ProcTHOR-Train-874.scene_instance.json", + "./2/ProcTHOR-Train-967.scene_instance.json", + "./2/ProcTHOR-Train-148.scene_instance.json", + "./2/ProcTHOR-Train-481.scene_instance.json", + "./2/ProcTHOR-Train-946.scene_instance.json", + "./2/ProcTHOR-Train-500.scene_instance.json", + "./2/ProcTHOR-Train-344.scene_instance.json", + "./2/ProcTHOR-Train-781.scene_instance.json", + "./2/ProcTHOR-Train-196.scene_instance.json", + "./2/ProcTHOR-Train-309.scene_instance.json", + "./2/ProcTHOR-Train-754.scene_instance.json", + "./2/ProcTHOR-Train-291.scene_instance.json", + "./2/ProcTHOR-Train-410.scene_instance.json", + "./2/ProcTHOR-Train-585.scene_instance.json", + "./2/ProcTHOR-Train-970.scene_instance.json", + "./2/ProcTHOR-Train-225.scene_instance.json", + "./2/ProcTHOR-Train-130.scene_instance.json", + "./2/ProcTHOR-Train-399.scene_instance.json", + "./2/ProcTHOR-Train-469.scene_instance.json", + "./2/ProcTHOR-Train-570.scene_instance.json", + "./2/ProcTHOR-Train-724.scene_instance.json", + "./2/ProcTHOR-Train-69.scene_instance.json", + "./2/ProcTHOR-Train-664.scene_instance.json", + "./2/ProcTHOR-Train-901.scene_instance.json", + "./2/ProcTHOR-Train-957.scene_instance.json", + "./2/ProcTHOR-Train-600.scene_instance.json", + "./2/ProcTHOR-Train-522.scene_instance.json", + "./2/ProcTHOR-Train-7.scene_instance.json", + "./2/ProcTHOR-Train-944.scene_instance.json", + "./2/ProcTHOR-Train-867.scene_instance.json", + "./2/ProcTHOR-Train-819.scene_instance.json", + "./2/ProcTHOR-Train-183.scene_instance.json", + "./2/ProcTHOR-Train-511.scene_instance.json", + "./2/ProcTHOR-Train-843.scene_instance.json", + "./2/ProcTHOR-Train-392.scene_instance.json", + "./2/ProcTHOR-Train-84.scene_instance.json", + "./2/ProcTHOR-Train-465.scene_instance.json", + "./2/ProcTHOR-Train-584.scene_instance.json", + "./2/ProcTHOR-Train-796.scene_instance.json", + "./2/ProcTHOR-Train-665.scene_instance.json", + "./2/ProcTHOR-Train-833.scene_instance.json", + "./2/ProcTHOR-Train-262.scene_instance.json", + "./2/ProcTHOR-Train-723.scene_instance.json", + "./2/ProcTHOR-Train-186.scene_instance.json", + "./2/ProcTHOR-Train-271.scene_instance.json", + "./2/ProcTHOR-Train-950.scene_instance.json", + "./2/ProcTHOR-Train-815.scene_instance.json", + "./2/ProcTHOR-Train-242.scene_instance.json", + "./2/ProcTHOR-Train-543.scene_instance.json", + "./2/ProcTHOR-Train-766.scene_instance.json", + "./2/ProcTHOR-Train-501.scene_instance.json", + "./2/ProcTHOR-Train-722.scene_instance.json", + "./2/ProcTHOR-Train-131.scene_instance.json", + "./2/ProcTHOR-Train-19.scene_instance.json", + "./2/ProcTHOR-Train-444.scene_instance.json", + "./2/ProcTHOR-Train-844.scene_instance.json", + "./2/ProcTHOR-Train-625.scene_instance.json", + "./2/ProcTHOR-Train-248.scene_instance.json", + "./2/ProcTHOR-Train-375.scene_instance.json", + "./2/ProcTHOR-Train-45.scene_instance.json", + "./2/ProcTHOR-Train-899.scene_instance.json", + "./2/ProcTHOR-Train-719.scene_instance.json", + "./2/ProcTHOR-Train-820.scene_instance.json", + "./2/ProcTHOR-Train-493.scene_instance.json", + "./2/ProcTHOR-Train-281.scene_instance.json", + "./2/ProcTHOR-Train-546.scene_instance.json", + "./2/ProcTHOR-Train-996.scene_instance.json", + "./2/ProcTHOR-Train-34.scene_instance.json", + "./2/ProcTHOR-Train-457.scene_instance.json", + "./2/ProcTHOR-Train-788.scene_instance.json", + "./2/ProcTHOR-Train-856.scene_instance.json", + "./2/ProcTHOR-Train-259.scene_instance.json", + "./2/ProcTHOR-Train-677.scene_instance.json", + "./2/ProcTHOR-Train-945.scene_instance.json", + "./2/ProcTHOR-Train-528.scene_instance.json", + "./2/ProcTHOR-Train-179.scene_instance.json", + "./2/ProcTHOR-Train-641.scene_instance.json", + "./2/ProcTHOR-Train-674.scene_instance.json", + "./2/ProcTHOR-Train-863.scene_instance.json", + "./2/ProcTHOR-Train-822.scene_instance.json", + "./2/ProcTHOR-Train-3.scene_instance.json", + "./2/ProcTHOR-Train-321.scene_instance.json", + "./2/ProcTHOR-Train-507.scene_instance.json", + "./2/ProcTHOR-Train-155.scene_instance.json", + "./2/ProcTHOR-Train-126.scene_instance.json", + "./2/ProcTHOR-Train-871.scene_instance.json", + "./2/ProcTHOR-Train-988.scene_instance.json", + "./2/ProcTHOR-Train-778.scene_instance.json", + "./2/ProcTHOR-Train-602.scene_instance.json", + "./2/ProcTHOR-Train-569.scene_instance.json", + "./2/ProcTHOR-Train-940.scene_instance.json", + "./2/ProcTHOR-Train-825.scene_instance.json", + "./2/ProcTHOR-Train-943.scene_instance.json", + "./2/ProcTHOR-Train-995.scene_instance.json", + "./2/ProcTHOR-Train-926.scene_instance.json", + "./2/ProcTHOR-Train-802.scene_instance.json", + "./2/ProcTHOR-Train-246.scene_instance.json", + "./2/ProcTHOR-Train-873.scene_instance.json", + "./2/ProcTHOR-Train-35.scene_instance.json", + "./2/ProcTHOR-Train-37.scene_instance.json", + "./2/ProcTHOR-Train-442.scene_instance.json", + "./2/ProcTHOR-Train-545.scene_instance.json", + "./2/ProcTHOR-Train-557.scene_instance.json", + "./2/ProcTHOR-Train-86.scene_instance.json", + "./2/ProcTHOR-Train-711.scene_instance.json", + "./2/ProcTHOR-Train-124.scene_instance.json", + "./2/ProcTHOR-Train-598.scene_instance.json", + "./2/ProcTHOR-Train-374.scene_instance.json", + "./2/ProcTHOR-Train-9.scene_instance.json", + "./2/ProcTHOR-Train-100.scene_instance.json", + "./2/ProcTHOR-Train-491.scene_instance.json", + "./2/ProcTHOR-Train-756.scene_instance.json", + "./2/ProcTHOR-Train-738.scene_instance.json", + "./2/ProcTHOR-Train-548.scene_instance.json", + "./2/ProcTHOR-Train-441.scene_instance.json", + "./2/ProcTHOR-Train-56.scene_instance.json", + "./2/ProcTHOR-Train-683.scene_instance.json", + "./2/ProcTHOR-Train-329.scene_instance.json", + "./2/ProcTHOR-Train-28.scene_instance.json", + "./2/ProcTHOR-Train-208.scene_instance.json", + "./2/ProcTHOR-Train-530.scene_instance.json", + "./2/ProcTHOR-Train-539.scene_instance.json", + "./2/ProcTHOR-Train-49.scene_instance.json", + "./2/ProcTHOR-Train-189.scene_instance.json", + "./2/ProcTHOR-Train-816.scene_instance.json", + "./2/ProcTHOR-Train-46.scene_instance.json", + "./2/ProcTHOR-Train-579.scene_instance.json", + "./2/ProcTHOR-Train-445.scene_instance.json", + "./2/ProcTHOR-Train-317.scene_instance.json", + "./2/ProcTHOR-Train-20.scene_instance.json", + "./2/ProcTHOR-Train-276.scene_instance.json", + "./2/ProcTHOR-Train-626.scene_instance.json", + "./2/ProcTHOR-Train-842.scene_instance.json", + "./2/ProcTHOR-Train-809.scene_instance.json", + "./2/ProcTHOR-Train-972.scene_instance.json", + "./2/ProcTHOR-Train-963.scene_instance.json", + "./2/ProcTHOR-Train-855.scene_instance.json", + "./2/ProcTHOR-Train-697.scene_instance.json", + "./2/ProcTHOR-Train-920.scene_instance.json", + "./2/ProcTHOR-Train-164.scene_instance.json", + "./2/ProcTHOR-Train-773.scene_instance.json", + "./2/ProcTHOR-Train-251.scene_instance.json", + "./2/ProcTHOR-Train-31.scene_instance.json", + "./2/ProcTHOR-Train-801.scene_instance.json", + "./2/ProcTHOR-Train-669.scene_instance.json", + "./2/ProcTHOR-Train-743.scene_instance.json", + "./2/ProcTHOR-Train-5.scene_instance.json", + "./2/ProcTHOR-Train-260.scene_instance.json", + "./2/ProcTHOR-Train-137.scene_instance.json", + "./2/ProcTHOR-Train-999.scene_instance.json", + "./2/ProcTHOR-Train-417.scene_instance.json", + "./2/ProcTHOR-Train-81.scene_instance.json", + "./2/ProcTHOR-Train-394.scene_instance.json", + "./2/ProcTHOR-Train-462.scene_instance.json", + "./2/ProcTHOR-Train-502.scene_instance.json", + "./2/ProcTHOR-Train-644.scene_instance.json", + "./2/ProcTHOR-Train-171.scene_instance.json", + "./2/ProcTHOR-Train-110.scene_instance.json", + "./2/ProcTHOR-Train-471.scene_instance.json", + "./2/ProcTHOR-Train-16.scene_instance.json", + "./2/ProcTHOR-Train-588.scene_instance.json", + "./2/ProcTHOR-Train-211.scene_instance.json", + "./2/ProcTHOR-Train-87.scene_instance.json", + "./2/ProcTHOR-Train-319.scene_instance.json", + "./2/ProcTHOR-Train-323.scene_instance.json", + "./2/ProcTHOR-Train-43.scene_instance.json", + "./2/ProcTHOR-Train-50.scene_instance.json", + "./2/ProcTHOR-Train-187.scene_instance.json", + "./2/ProcTHOR-Train-97.scene_instance.json", + "./2/ProcTHOR-Train-430.scene_instance.json", + "./2/ProcTHOR-Train-188.scene_instance.json", + "./2/ProcTHOR-Train-506.scene_instance.json", + "./2/ProcTHOR-Train-1.scene_instance.json", + "./2/ProcTHOR-Train-876.scene_instance.json", + "./2/ProcTHOR-Train-114.scene_instance.json", + "./2/ProcTHOR-Train-158.scene_instance.json", + "./2/ProcTHOR-Train-589.scene_instance.json", + "./2/ProcTHOR-Train-431.scene_instance.json", + "./2/ProcTHOR-Train-280.scene_instance.json", + "./2/ProcTHOR-Train-54.scene_instance.json", + "./2/ProcTHOR-Train-696.scene_instance.json", + "./6/ProcTHOR-Train-4019.scene_instance.json", + "./6/ProcTHOR-Train-4083.scene_instance.json", + "./6/ProcTHOR-Train-4468.scene_instance.json", + "./6/ProcTHOR-Train-4179.scene_instance.json", + "./6/ProcTHOR-Train-4640.scene_instance.json", + "./6/ProcTHOR-Train-4149.scene_instance.json", + "./6/ProcTHOR-Train-4829.scene_instance.json", + "./6/ProcTHOR-Train-4964.scene_instance.json", + "./6/ProcTHOR-Train-4875.scene_instance.json", + "./6/ProcTHOR-Train-4891.scene_instance.json", + "./6/ProcTHOR-Train-4824.scene_instance.json", + "./6/ProcTHOR-Train-4025.scene_instance.json", + "./6/ProcTHOR-Train-4064.scene_instance.json", + "./6/ProcTHOR-Train-4885.scene_instance.json", + "./6/ProcTHOR-Train-4510.scene_instance.json", + "./6/ProcTHOR-Train-4100.scene_instance.json", + "./6/ProcTHOR-Train-4717.scene_instance.json", + "./6/ProcTHOR-Train-4132.scene_instance.json", + "./6/ProcTHOR-Train-4788.scene_instance.json", + "./6/ProcTHOR-Train-4905.scene_instance.json", + "./6/ProcTHOR-Train-4162.scene_instance.json", + "./6/ProcTHOR-Train-4326.scene_instance.json", + "./6/ProcTHOR-Train-4086.scene_instance.json", + "./6/ProcTHOR-Train-4668.scene_instance.json", + "./6/ProcTHOR-Train-4892.scene_instance.json", + "./6/ProcTHOR-Train-4768.scene_instance.json", + "./6/ProcTHOR-Train-4695.scene_instance.json", + "./6/ProcTHOR-Train-4924.scene_instance.json", + "./6/ProcTHOR-Train-4918.scene_instance.json", + "./6/ProcTHOR-Train-4422.scene_instance.json", + "./6/ProcTHOR-Train-4288.scene_instance.json", + "./6/ProcTHOR-Train-4437.scene_instance.json", + "./6/ProcTHOR-Train-4430.scene_instance.json", + "./6/ProcTHOR-Train-4513.scene_instance.json", + "./6/ProcTHOR-Train-4101.scene_instance.json", + "./6/ProcTHOR-Train-4690.scene_instance.json", + "./6/ProcTHOR-Train-4366.scene_instance.json", + "./6/ProcTHOR-Train-4118.scene_instance.json", + "./6/ProcTHOR-Train-4190.scene_instance.json", + "./6/ProcTHOR-Train-4585.scene_instance.json", + "./6/ProcTHOR-Train-4200.scene_instance.json", + "./6/ProcTHOR-Train-4371.scene_instance.json", + "./6/ProcTHOR-Train-4159.scene_instance.json", + "./6/ProcTHOR-Train-4073.scene_instance.json", + "./6/ProcTHOR-Train-4761.scene_instance.json", + "./6/ProcTHOR-Train-4807.scene_instance.json", + "./6/ProcTHOR-Train-4727.scene_instance.json", + "./6/ProcTHOR-Train-4509.scene_instance.json", + "./6/ProcTHOR-Train-4311.scene_instance.json", + "./6/ProcTHOR-Train-4042.scene_instance.json", + "./6/ProcTHOR-Train-4408.scene_instance.json", + "./6/ProcTHOR-Train-4572.scene_instance.json", + "./6/ProcTHOR-Train-4604.scene_instance.json", + "./6/ProcTHOR-Train-4853.scene_instance.json", + "./6/ProcTHOR-Train-4561.scene_instance.json", + "./6/ProcTHOR-Train-4863.scene_instance.json", + "./6/ProcTHOR-Train-4752.scene_instance.json", + "./6/ProcTHOR-Train-4501.scene_instance.json", + "./6/ProcTHOR-Train-4609.scene_instance.json", + "./6/ProcTHOR-Train-4519.scene_instance.json", + "./6/ProcTHOR-Train-4637.scene_instance.json", + "./6/ProcTHOR-Train-4141.scene_instance.json", + "./6/ProcTHOR-Train-4002.scene_instance.json", + "./6/ProcTHOR-Train-4898.scene_instance.json", + "./6/ProcTHOR-Train-4992.scene_instance.json", + "./6/ProcTHOR-Train-4974.scene_instance.json", + "./6/ProcTHOR-Train-4387.scene_instance.json", + "./6/ProcTHOR-Train-4462.scene_instance.json", + "./6/ProcTHOR-Train-4936.scene_instance.json", + "./6/ProcTHOR-Train-4523.scene_instance.json", + "./6/ProcTHOR-Train-4632.scene_instance.json", + "./6/ProcTHOR-Train-4143.scene_instance.json", + "./6/ProcTHOR-Train-4535.scene_instance.json", + "./6/ProcTHOR-Train-4034.scene_instance.json", + "./6/ProcTHOR-Train-4409.scene_instance.json", + "./6/ProcTHOR-Train-4627.scene_instance.json", + "./6/ProcTHOR-Train-4991.scene_instance.json", + "./6/ProcTHOR-Train-4745.scene_instance.json", + "./6/ProcTHOR-Train-4699.scene_instance.json", + "./6/ProcTHOR-Train-4455.scene_instance.json", + "./6/ProcTHOR-Train-4248.scene_instance.json", + "./6/ProcTHOR-Train-4578.scene_instance.json", + "./6/ProcTHOR-Train-4363.scene_instance.json", + "./6/ProcTHOR-Train-4869.scene_instance.json", + "./6/ProcTHOR-Train-4144.scene_instance.json", + "./6/ProcTHOR-Train-4180.scene_instance.json", + "./6/ProcTHOR-Train-4338.scene_instance.json", + "./6/ProcTHOR-Train-4667.scene_instance.json", + "./6/ProcTHOR-Train-4060.scene_instance.json", + "./6/ProcTHOR-Train-4235.scene_instance.json", + "./6/ProcTHOR-Train-4186.scene_instance.json", + "./6/ProcTHOR-Train-4370.scene_instance.json", + "./6/ProcTHOR-Train-4524.scene_instance.json", + "./6/ProcTHOR-Train-4876.scene_instance.json", + "./6/ProcTHOR-Train-4603.scene_instance.json", + "./6/ProcTHOR-Train-4041.scene_instance.json", + "./6/ProcTHOR-Train-4789.scene_instance.json", + "./6/ProcTHOR-Train-4786.scene_instance.json", + "./6/ProcTHOR-Train-4312.scene_instance.json", + "./6/ProcTHOR-Train-4662.scene_instance.json", + "./6/ProcTHOR-Train-4196.scene_instance.json", + "./6/ProcTHOR-Train-4018.scene_instance.json", + "./6/ProcTHOR-Train-4037.scene_instance.json", + "./6/ProcTHOR-Train-4594.scene_instance.json", + "./6/ProcTHOR-Train-4725.scene_instance.json", + "./6/ProcTHOR-Train-4581.scene_instance.json", + "./6/ProcTHOR-Train-4508.scene_instance.json", + "./6/ProcTHOR-Train-4205.scene_instance.json", + "./6/ProcTHOR-Train-4729.scene_instance.json", + "./6/ProcTHOR-Train-4127.scene_instance.json", + "./6/ProcTHOR-Train-4825.scene_instance.json", + "./6/ProcTHOR-Train-4658.scene_instance.json", + "./6/ProcTHOR-Train-4130.scene_instance.json", + "./6/ProcTHOR-Train-4944.scene_instance.json", + "./6/ProcTHOR-Train-4220.scene_instance.json", + "./6/ProcTHOR-Train-4266.scene_instance.json", + "./6/ProcTHOR-Train-4612.scene_instance.json", + "./6/ProcTHOR-Train-4672.scene_instance.json", + "./6/ProcTHOR-Train-4480.scene_instance.json", + "./6/ProcTHOR-Train-4942.scene_instance.json", + "./6/ProcTHOR-Train-4031.scene_instance.json", + "./6/ProcTHOR-Train-4583.scene_instance.json", + "./6/ProcTHOR-Train-4530.scene_instance.json", + "./6/ProcTHOR-Train-4801.scene_instance.json", + "./6/ProcTHOR-Train-4660.scene_instance.json", + "./6/ProcTHOR-Train-4168.scene_instance.json", + "./6/ProcTHOR-Train-4625.scene_instance.json", + "./6/ProcTHOR-Train-4198.scene_instance.json", + "./6/ProcTHOR-Train-4233.scene_instance.json", + "./6/ProcTHOR-Train-4757.scene_instance.json", + "./6/ProcTHOR-Train-4973.scene_instance.json", + "./6/ProcTHOR-Train-4431.scene_instance.json", + "./6/ProcTHOR-Train-4088.scene_instance.json", + "./6/ProcTHOR-Train-4332.scene_instance.json", + "./6/ProcTHOR-Train-4358.scene_instance.json", + "./6/ProcTHOR-Train-4893.scene_instance.json", + "./6/ProcTHOR-Train-4356.scene_instance.json", + "./6/ProcTHOR-Train-4888.scene_instance.json", + "./6/ProcTHOR-Train-4221.scene_instance.json", + "./6/ProcTHOR-Train-4119.scene_instance.json", + "./6/ProcTHOR-Train-4040.scene_instance.json", + "./6/ProcTHOR-Train-4903.scene_instance.json", + "./6/ProcTHOR-Train-4656.scene_instance.json", + "./6/ProcTHOR-Train-4201.scene_instance.json", + "./6/ProcTHOR-Train-4845.scene_instance.json", + "./6/ProcTHOR-Train-4377.scene_instance.json", + "./6/ProcTHOR-Train-4542.scene_instance.json", + "./6/ProcTHOR-Train-4236.scene_instance.json", + "./6/ProcTHOR-Train-4208.scene_instance.json", + "./6/ProcTHOR-Train-4188.scene_instance.json", + "./6/ProcTHOR-Train-4533.scene_instance.json", + "./6/ProcTHOR-Train-4309.scene_instance.json", + "./6/ProcTHOR-Train-4022.scene_instance.json", + "./6/ProcTHOR-Train-4275.scene_instance.json", + "./6/ProcTHOR-Train-4257.scene_instance.json", + "./6/ProcTHOR-Train-4698.scene_instance.json", + "./6/ProcTHOR-Train-4586.scene_instance.json", + "./6/ProcTHOR-Train-4286.scene_instance.json", + "./6/ProcTHOR-Train-4666.scene_instance.json", + "./6/ProcTHOR-Train-4300.scene_instance.json", + "./6/ProcTHOR-Train-4217.scene_instance.json", + "./6/ProcTHOR-Train-4494.scene_instance.json", + "./6/ProcTHOR-Train-4174.scene_instance.json", + "./6/ProcTHOR-Train-4376.scene_instance.json", + "./6/ProcTHOR-Train-4049.scene_instance.json", + "./6/ProcTHOR-Train-4328.scene_instance.json", + "./6/ProcTHOR-Train-4912.scene_instance.json", + "./6/ProcTHOR-Train-4998.scene_instance.json", + "./6/ProcTHOR-Train-4528.scene_instance.json", + "./6/ProcTHOR-Train-4232.scene_instance.json", + "./6/ProcTHOR-Train-4802.scene_instance.json", + "./6/ProcTHOR-Train-4539.scene_instance.json", + "./6/ProcTHOR-Train-4544.scene_instance.json", + "./6/ProcTHOR-Train-4105.scene_instance.json", + "./6/ProcTHOR-Train-4568.scene_instance.json", + "./6/ProcTHOR-Train-4692.scene_instance.json", + "./6/ProcTHOR-Train-4820.scene_instance.json", + "./6/ProcTHOR-Train-4915.scene_instance.json", + "./6/ProcTHOR-Train-4365.scene_instance.json", + "./6/ProcTHOR-Train-4870.scene_instance.json", + "./6/ProcTHOR-Train-4989.scene_instance.json", + "./6/ProcTHOR-Train-4439.scene_instance.json", + "./6/ProcTHOR-Train-4734.scene_instance.json", + "./6/ProcTHOR-Train-4470.scene_instance.json", + "./6/ProcTHOR-Train-4993.scene_instance.json", + "./6/ProcTHOR-Train-4795.scene_instance.json", + "./6/ProcTHOR-Train-4273.scene_instance.json", + "./6/ProcTHOR-Train-4213.scene_instance.json", + "./6/ProcTHOR-Train-4986.scene_instance.json", + "./6/ProcTHOR-Train-4896.scene_instance.json", + "./6/ProcTHOR-Train-4033.scene_instance.json", + "./6/ProcTHOR-Train-4441.scene_instance.json", + "./6/ProcTHOR-Train-4520.scene_instance.json", + "./6/ProcTHOR-Train-4500.scene_instance.json", + "./6/ProcTHOR-Train-4438.scene_instance.json", + "./6/ProcTHOR-Train-4506.scene_instance.json", + "./6/ProcTHOR-Train-4450.scene_instance.json", + "./6/ProcTHOR-Train-4929.scene_instance.json", + "./6/ProcTHOR-Train-4579.scene_instance.json", + "./6/ProcTHOR-Train-4435.scene_instance.json", + "./6/ProcTHOR-Train-4955.scene_instance.json", + "./6/ProcTHOR-Train-4746.scene_instance.json", + "./6/ProcTHOR-Train-4306.scene_instance.json", + "./6/ProcTHOR-Train-4503.scene_instance.json", + "./6/ProcTHOR-Train-4702.scene_instance.json", + "./6/ProcTHOR-Train-4110.scene_instance.json", + "./6/ProcTHOR-Train-4046.scene_instance.json", + "./6/ProcTHOR-Train-4420.scene_instance.json", + "./6/ProcTHOR-Train-4050.scene_instance.json", + "./6/ProcTHOR-Train-4846.scene_instance.json", + "./6/ProcTHOR-Train-4016.scene_instance.json", + "./6/ProcTHOR-Train-4626.scene_instance.json", + "./6/ProcTHOR-Train-4890.scene_instance.json", + "./6/ProcTHOR-Train-4852.scene_instance.json", + "./6/ProcTHOR-Train-4483.scene_instance.json", + "./6/ProcTHOR-Train-4403.scene_instance.json", + "./6/ProcTHOR-Train-4613.scene_instance.json", + "./6/ProcTHOR-Train-4259.scene_instance.json", + "./6/ProcTHOR-Train-4367.scene_instance.json", + "./6/ProcTHOR-Train-4754.scene_instance.json", + "./6/ProcTHOR-Train-4958.scene_instance.json", + "./6/ProcTHOR-Train-4983.scene_instance.json", + "./6/ProcTHOR-Train-4351.scene_instance.json", + "./6/ProcTHOR-Train-4163.scene_instance.json", + "./6/ProcTHOR-Train-4550.scene_instance.json", + "./6/ProcTHOR-Train-4044.scene_instance.json", + "./6/ProcTHOR-Train-4442.scene_instance.json", + "./6/ProcTHOR-Train-4339.scene_instance.json", + "./6/ProcTHOR-Train-4724.scene_instance.json", + "./6/ProcTHOR-Train-4212.scene_instance.json", + "./6/ProcTHOR-Train-4317.scene_instance.json", + "./6/ProcTHOR-Train-4988.scene_instance.json", + "./6/ProcTHOR-Train-4848.scene_instance.json", + "./6/ProcTHOR-Train-4823.scene_instance.json", + "./6/ProcTHOR-Train-4007.scene_instance.json", + "./6/ProcTHOR-Train-4996.scene_instance.json", + "./6/ProcTHOR-Train-4792.scene_instance.json", + "./6/ProcTHOR-Train-4884.scene_instance.json", + "./6/ProcTHOR-Train-4818.scene_instance.json", + "./6/ProcTHOR-Train-4551.scene_instance.json", + "./6/ProcTHOR-Train-4731.scene_instance.json", + "./6/ProcTHOR-Train-4479.scene_instance.json", + "./6/ProcTHOR-Train-4178.scene_instance.json", + "./6/ProcTHOR-Train-4962.scene_instance.json", + "./6/ProcTHOR-Train-4766.scene_instance.json", + "./6/ProcTHOR-Train-4722.scene_instance.json", + "./6/ProcTHOR-Train-4574.scene_instance.json", + "./6/ProcTHOR-Train-4270.scene_instance.json", + "./6/ProcTHOR-Train-4794.scene_instance.json", + "./6/ProcTHOR-Train-4758.scene_instance.json", + "./6/ProcTHOR-Train-4401.scene_instance.json", + "./6/ProcTHOR-Train-4709.scene_instance.json", + "./6/ProcTHOR-Train-4624.scene_instance.json", + "./6/ProcTHOR-Train-4057.scene_instance.json", + "./6/ProcTHOR-Train-4072.scene_instance.json", + "./6/ProcTHOR-Train-4593.scene_instance.json", + "./6/ProcTHOR-Train-4803.scene_instance.json", + "./6/ProcTHOR-Train-4474.scene_instance.json", + "./6/ProcTHOR-Train-4386.scene_instance.json", + "./6/ProcTHOR-Train-4045.scene_instance.json", + "./6/ProcTHOR-Train-4733.scene_instance.json", + "./6/ProcTHOR-Train-4744.scene_instance.json", + "./6/ProcTHOR-Train-4063.scene_instance.json", + "./6/ProcTHOR-Train-4742.scene_instance.json", + "./6/ProcTHOR-Train-4782.scene_instance.json", + "./6/ProcTHOR-Train-4669.scene_instance.json", + "./6/ProcTHOR-Train-4543.scene_instance.json", + "./6/ProcTHOR-Train-4475.scene_instance.json", + "./6/ProcTHOR-Train-4531.scene_instance.json", + "./6/ProcTHOR-Train-4599.scene_instance.json", + "./6/ProcTHOR-Train-4185.scene_instance.json", + "./6/ProcTHOR-Train-4466.scene_instance.json", + "./6/ProcTHOR-Train-4000.scene_instance.json", + "./6/ProcTHOR-Train-4425.scene_instance.json", + "./6/ProcTHOR-Train-4169.scene_instance.json", + "./6/ProcTHOR-Train-4145.scene_instance.json", + "./6/ProcTHOR-Train-4048.scene_instance.json", + "./6/ProcTHOR-Train-4218.scene_instance.json", + "./6/ProcTHOR-Train-4629.scene_instance.json", + "./6/ProcTHOR-Train-4546.scene_instance.json", + "./6/ProcTHOR-Train-4810.scene_instance.json", + "./6/ProcTHOR-Train-4497.scene_instance.json", + "./6/ProcTHOR-Train-4103.scene_instance.json", + "./6/ProcTHOR-Train-4976.scene_instance.json", + "./6/ProcTHOR-Train-4111.scene_instance.json", + "./6/ProcTHOR-Train-4504.scene_instance.json", + "./6/ProcTHOR-Train-4463.scene_instance.json", + "./6/ProcTHOR-Train-4916.scene_instance.json", + "./6/ProcTHOR-Train-4675.scene_instance.json", + "./6/ProcTHOR-Train-4164.scene_instance.json", + "./6/ProcTHOR-Train-4082.scene_instance.json", + "./6/ProcTHOR-Train-4648.scene_instance.json", + "./6/ProcTHOR-Train-4681.scene_instance.json", + "./6/ProcTHOR-Train-4567.scene_instance.json", + "./6/ProcTHOR-Train-4984.scene_instance.json", + "./6/ProcTHOR-Train-4133.scene_instance.json", + "./6/ProcTHOR-Train-4529.scene_instance.json", + "./6/ProcTHOR-Train-4123.scene_instance.json", + "./6/ProcTHOR-Train-4244.scene_instance.json", + "./6/ProcTHOR-Train-4247.scene_instance.json", + "./6/ProcTHOR-Train-4478.scene_instance.json", + "./6/ProcTHOR-Train-4482.scene_instance.json", + "./6/ProcTHOR-Train-4835.scene_instance.json", + "./6/ProcTHOR-Train-4117.scene_instance.json", + "./6/ProcTHOR-Train-4553.scene_instance.json", + "./6/ProcTHOR-Train-4655.scene_instance.json", + "./6/ProcTHOR-Train-4098.scene_instance.json", + "./6/ProcTHOR-Train-4837.scene_instance.json", + "./6/ProcTHOR-Train-4756.scene_instance.json", + "./6/ProcTHOR-Train-4140.scene_instance.json", + "./6/ProcTHOR-Train-4146.scene_instance.json", + "./6/ProcTHOR-Train-4557.scene_instance.json", + "./6/ProcTHOR-Train-4254.scene_instance.json", + "./6/ProcTHOR-Train-4600.scene_instance.json", + "./6/ProcTHOR-Train-4844.scene_instance.json", + "./6/ProcTHOR-Train-4705.scene_instance.json", + "./6/ProcTHOR-Train-4584.scene_instance.json", + "./6/ProcTHOR-Train-4688.scene_instance.json", + "./6/ProcTHOR-Train-4772.scene_instance.json", + "./6/ProcTHOR-Train-4134.scene_instance.json", + "./6/ProcTHOR-Train-4920.scene_instance.json", + "./6/ProcTHOR-Train-4926.scene_instance.json", + "./6/ProcTHOR-Train-4263.scene_instance.json", + "./6/ProcTHOR-Train-4310.scene_instance.json", + "./6/ProcTHOR-Train-4492.scene_instance.json", + "./6/ProcTHOR-Train-4461.scene_instance.json", + "./6/ProcTHOR-Train-4953.scene_instance.json", + "./6/ProcTHOR-Train-4136.scene_instance.json", + "./6/ProcTHOR-Train-4511.scene_instance.json", + "./6/ProcTHOR-Train-4977.scene_instance.json", + "./6/ProcTHOR-Train-4161.scene_instance.json", + "./6/ProcTHOR-Train-4952.scene_instance.json", + "./6/ProcTHOR-Train-4642.scene_instance.json", + "./6/ProcTHOR-Train-4798.scene_instance.json", + "./6/ProcTHOR-Train-4670.scene_instance.json", + "./6/ProcTHOR-Train-4689.scene_instance.json", + "./6/ProcTHOR-Train-4301.scene_instance.json", + "./6/ProcTHOR-Train-4155.scene_instance.json", + "./6/ProcTHOR-Train-4999.scene_instance.json", + "./6/ProcTHOR-Train-4122.scene_instance.json", + "./6/ProcTHOR-Train-4415.scene_instance.json", + "./6/ProcTHOR-Train-4176.scene_instance.json", + "./6/ProcTHOR-Train-4489.scene_instance.json", + "./6/ProcTHOR-Train-4804.scene_instance.json", + "./6/ProcTHOR-Train-4933.scene_instance.json", + "./6/ProcTHOR-Train-4239.scene_instance.json", + "./6/ProcTHOR-Train-4272.scene_instance.json", + "./6/ProcTHOR-Train-4490.scene_instance.json", + "./6/ProcTHOR-Train-4950.scene_instance.json", + "./6/ProcTHOR-Train-4602.scene_instance.json", + "./6/ProcTHOR-Train-4353.scene_instance.json", + "./6/ProcTHOR-Train-4925.scene_instance.json", + "./6/ProcTHOR-Train-4265.scene_instance.json", + "./6/ProcTHOR-Train-4703.scene_instance.json", + "./6/ProcTHOR-Train-4284.scene_instance.json", + "./6/ProcTHOR-Train-4555.scene_instance.json", + "./6/ProcTHOR-Train-4806.scene_instance.json", + "./6/ProcTHOR-Train-4166.scene_instance.json", + "./6/ProcTHOR-Train-4540.scene_instance.json", + "./6/ProcTHOR-Train-4183.scene_instance.json", + "./6/ProcTHOR-Train-4347.scene_instance.json", + "./6/ProcTHOR-Train-4719.scene_instance.json", + "./6/ProcTHOR-Train-4871.scene_instance.json", + "./6/ProcTHOR-Train-4701.scene_instance.json", + "./6/ProcTHOR-Train-4644.scene_instance.json", + "./6/ProcTHOR-Train-4258.scene_instance.json", + "./6/ProcTHOR-Train-4053.scene_instance.json", + "./6/ProcTHOR-Train-4303.scene_instance.json", + "./6/ProcTHOR-Train-4859.scene_instance.json", + "./6/ProcTHOR-Train-4904.scene_instance.json", + "./6/ProcTHOR-Train-4194.scene_instance.json", + "./6/ProcTHOR-Train-4960.scene_instance.json", + "./6/ProcTHOR-Train-4354.scene_instance.json", + "./6/ProcTHOR-Train-4187.scene_instance.json", + "./6/ProcTHOR-Train-4051.scene_instance.json", + "./6/ProcTHOR-Train-4011.scene_instance.json", + "./6/ProcTHOR-Train-4939.scene_instance.json", + "./6/ProcTHOR-Train-4043.scene_instance.json", + "./6/ProcTHOR-Train-4932.scene_instance.json", + "./6/ProcTHOR-Train-4285.scene_instance.json", + "./6/ProcTHOR-Train-4639.scene_instance.json", + "./6/ProcTHOR-Train-4559.scene_instance.json", + "./6/ProcTHOR-Train-4659.scene_instance.json", + "./6/ProcTHOR-Train-4735.scene_instance.json", + "./6/ProcTHOR-Train-4380.scene_instance.json", + "./6/ProcTHOR-Train-4299.scene_instance.json", + "./6/ProcTHOR-Train-4278.scene_instance.json", + "./6/ProcTHOR-Train-4650.scene_instance.json", + "./6/ProcTHOR-Train-4129.scene_instance.json", + "./6/ProcTHOR-Train-4013.scene_instance.json", + "./6/ProcTHOR-Train-4293.scene_instance.json", + "./6/ProcTHOR-Train-4193.scene_instance.json", + "./6/ProcTHOR-Train-4352.scene_instance.json", + "./6/ProcTHOR-Train-4799.scene_instance.json", + "./6/ProcTHOR-Train-4618.scene_instance.json", + "./6/ProcTHOR-Train-4062.scene_instance.json", + "./6/ProcTHOR-Train-4457.scene_instance.json", + "./6/ProcTHOR-Train-4305.scene_instance.json", + "./6/ProcTHOR-Train-4704.scene_instance.json", + "./6/ProcTHOR-Train-4963.scene_instance.json", + "./6/ProcTHOR-Train-4459.scene_instance.json", + "./6/ProcTHOR-Train-4003.scene_instance.json", + "./6/ProcTHOR-Train-4109.scene_instance.json", + "./6/ProcTHOR-Train-4564.scene_instance.json", + "./6/ProcTHOR-Train-4327.scene_instance.json", + "./6/ProcTHOR-Train-4966.scene_instance.json", + "./6/ProcTHOR-Train-4191.scene_instance.json", + "./6/ProcTHOR-Train-4811.scene_instance.json", + "./6/ProcTHOR-Train-4940.scene_instance.json", + "./6/ProcTHOR-Train-4346.scene_instance.json", + "./6/ProcTHOR-Train-4948.scene_instance.json", + "./6/ProcTHOR-Train-4238.scene_instance.json", + "./6/ProcTHOR-Train-4150.scene_instance.json", + "./6/ProcTHOR-Train-4587.scene_instance.json", + "./6/ProcTHOR-Train-4402.scene_instance.json", + "./6/ProcTHOR-Train-4245.scene_instance.json", + "./6/ProcTHOR-Train-4372.scene_instance.json", + "./6/ProcTHOR-Train-4268.scene_instance.json", + "./6/ProcTHOR-Train-4189.scene_instance.json", + "./6/ProcTHOR-Train-4192.scene_instance.json", + "./6/ProcTHOR-Train-4423.scene_instance.json", + "./6/ProcTHOR-Train-4471.scene_instance.json", + "./6/ProcTHOR-Train-4671.scene_instance.json", + "./6/ProcTHOR-Train-4930.scene_instance.json", + "./6/ProcTHOR-Train-4216.scene_instance.json", + "./6/ProcTHOR-Train-4026.scene_instance.json", + "./6/ProcTHOR-Train-4460.scene_instance.json", + "./6/ProcTHOR-Train-4663.scene_instance.json", + "./6/ProcTHOR-Train-4674.scene_instance.json", + "./6/ProcTHOR-Train-4779.scene_instance.json", + "./6/ProcTHOR-Train-4749.scene_instance.json", + "./6/ProcTHOR-Train-4325.scene_instance.json", + "./6/ProcTHOR-Train-4251.scene_instance.json", + "./6/ProcTHOR-Train-4921.scene_instance.json", + "./6/ProcTHOR-Train-4395.scene_instance.json", + "./6/ProcTHOR-Train-4404.scene_instance.json", + "./6/ProcTHOR-Train-4934.scene_instance.json", + "./6/ProcTHOR-Train-4850.scene_instance.json", + "./6/ProcTHOR-Train-4298.scene_instance.json", + "./6/ProcTHOR-Train-4515.scene_instance.json", + "./6/ProcTHOR-Train-4260.scene_instance.json", + "./6/ProcTHOR-Train-4451.scene_instance.json", + "./6/ProcTHOR-Train-4868.scene_instance.json", + "./6/ProcTHOR-Train-4330.scene_instance.json", + "./6/ProcTHOR-Train-4684.scene_instance.json", + "./6/ProcTHOR-Train-4115.scene_instance.json", + "./6/ProcTHOR-Train-4710.scene_instance.json", + "./6/ProcTHOR-Train-4158.scene_instance.json", + "./6/ProcTHOR-Train-4066.scene_instance.json", + "./6/ProcTHOR-Train-4400.scene_instance.json", + "./6/ProcTHOR-Train-4156.scene_instance.json", + "./6/ProcTHOR-Train-4838.scene_instance.json", + "./6/ProcTHOR-Train-4396.scene_instance.json", + "./6/ProcTHOR-Train-4021.scene_instance.json", + "./6/ProcTHOR-Train-4324.scene_instance.json", + "./6/ProcTHOR-Train-4633.scene_instance.json", + "./6/ProcTHOR-Train-4570.scene_instance.json", + "./6/ProcTHOR-Train-4728.scene_instance.json", + "./6/ProcTHOR-Train-4812.scene_instance.json", + "./6/ProcTHOR-Train-4759.scene_instance.json", + "./6/ProcTHOR-Train-4923.scene_instance.json", + "./6/ProcTHOR-Train-4982.scene_instance.json", + "./6/ProcTHOR-Train-4945.scene_instance.json", + "./6/ProcTHOR-Train-4148.scene_instance.json", + "./6/ProcTHOR-Train-4077.scene_instance.json", + "./6/ProcTHOR-Train-4715.scene_instance.json", + "./6/ProcTHOR-Train-4691.scene_instance.json", + "./6/ProcTHOR-Train-4131.scene_instance.json", + "./6/ProcTHOR-Train-4972.scene_instance.json", + "./6/ProcTHOR-Train-4854.scene_instance.json", + "./6/ProcTHOR-Train-4289.scene_instance.json", + "./6/ProcTHOR-Train-4817.scene_instance.json", + "./6/ProcTHOR-Train-4634.scene_instance.json", + "./6/ProcTHOR-Train-4615.scene_instance.json", + "./6/ProcTHOR-Train-4440.scene_instance.json", + "./6/ProcTHOR-Train-4499.scene_instance.json", + "./6/ProcTHOR-Train-4773.scene_instance.json", + "./6/ProcTHOR-Train-4125.scene_instance.json", + "./6/ProcTHOR-Train-4791.scene_instance.json", + "./6/ProcTHOR-Train-4261.scene_instance.json", + "./6/ProcTHOR-Train-4160.scene_instance.json", + "./6/ProcTHOR-Train-4636.scene_instance.json", + "./6/ProcTHOR-Train-4170.scene_instance.json", + "./6/ProcTHOR-Train-4521.scene_instance.json", + "./6/ProcTHOR-Train-4379.scene_instance.json", + "./6/ProcTHOR-Train-4796.scene_instance.json", + "./6/ProcTHOR-Train-4816.scene_instance.json", + "./6/ProcTHOR-Train-4857.scene_instance.json", + "./6/ProcTHOR-Train-4565.scene_instance.json", + "./6/ProcTHOR-Train-4949.scene_instance.json", + "./6/ProcTHOR-Train-4433.scene_instance.json", + "./6/ProcTHOR-Train-4080.scene_instance.json", + "./6/ProcTHOR-Train-4215.scene_instance.json", + "./6/ProcTHOR-Train-4879.scene_instance.json", + "./6/ProcTHOR-Train-4990.scene_instance.json", + "./6/ProcTHOR-Train-4255.scene_instance.json", + "./6/ProcTHOR-Train-4382.scene_instance.json", + "./6/ProcTHOR-Train-4880.scene_instance.json", + "./6/ProcTHOR-Train-4414.scene_instance.json", + "./6/ProcTHOR-Train-4665.scene_instance.json", + "./6/ProcTHOR-Train-4832.scene_instance.json", + "./6/ProcTHOR-Train-4716.scene_instance.json", + "./6/ProcTHOR-Train-4538.scene_instance.json", + "./6/ProcTHOR-Train-4620.scene_instance.json", + "./6/ProcTHOR-Train-4855.scene_instance.json", + "./6/ProcTHOR-Train-4588.scene_instance.json", + "./6/ProcTHOR-Train-4128.scene_instance.json", + "./6/ProcTHOR-Train-4496.scene_instance.json", + "./6/ProcTHOR-Train-4385.scene_instance.json", + "./6/ProcTHOR-Train-4711.scene_instance.json", + "./6/ProcTHOR-Train-4184.scene_instance.json", + "./6/ProcTHOR-Train-4980.scene_instance.json", + "./6/ProcTHOR-Train-4090.scene_instance.json", + "./6/ProcTHOR-Train-4014.scene_instance.json", + "./6/ProcTHOR-Train-4313.scene_instance.json", + "./6/ProcTHOR-Train-4151.scene_instance.json", + "./6/ProcTHOR-Train-4608.scene_instance.json", + "./6/ProcTHOR-Train-4619.scene_instance.json", + "./6/ProcTHOR-Train-4747.scene_instance.json", + "./6/ProcTHOR-Train-4979.scene_instance.json", + "./6/ProcTHOR-Train-4922.scene_instance.json", + "./6/ProcTHOR-Train-4545.scene_instance.json", + "./6/ProcTHOR-Train-4680.scene_instance.json", + "./6/ProcTHOR-Train-4005.scene_instance.json", + "./6/ProcTHOR-Train-4781.scene_instance.json", + "./6/ProcTHOR-Train-4052.scene_instance.json", + "./6/ProcTHOR-Train-4784.scene_instance.json", + "./6/ProcTHOR-Train-4124.scene_instance.json", + "./6/ProcTHOR-Train-4094.scene_instance.json", + "./6/ProcTHOR-Train-4424.scene_instance.json", + "./6/ProcTHOR-Train-4900.scene_instance.json", + "./6/ProcTHOR-Train-4452.scene_instance.json", + "./6/ProcTHOR-Train-4805.scene_instance.json", + "./6/ProcTHOR-Train-4113.scene_instance.json", + "./6/ProcTHOR-Train-4446.scene_instance.json", + "./6/ProcTHOR-Train-4316.scene_instance.json", + "./6/ProcTHOR-Train-4337.scene_instance.json", + "./6/ProcTHOR-Train-4291.scene_instance.json", + "./6/ProcTHOR-Train-4056.scene_instance.json", + "./6/ProcTHOR-Train-4388.scene_instance.json", + "./6/ProcTHOR-Train-4762.scene_instance.json", + "./6/ProcTHOR-Train-4679.scene_instance.json", + "./6/ProcTHOR-Train-4350.scene_instance.json", + "./6/ProcTHOR-Train-4171.scene_instance.json", + "./6/ProcTHOR-Train-4473.scene_instance.json", + "./6/ProcTHOR-Train-4099.scene_instance.json", + "./6/ProcTHOR-Train-4391.scene_instance.json", + "./6/ProcTHOR-Train-4120.scene_instance.json", + "./6/ProcTHOR-Train-4226.scene_instance.json", + "./6/ProcTHOR-Train-4398.scene_instance.json", + "./6/ProcTHOR-Train-4737.scene_instance.json", + "./6/ProcTHOR-Train-4595.scene_instance.json", + "./6/ProcTHOR-Train-4202.scene_instance.json", + "./6/ProcTHOR-Train-4697.scene_instance.json", + "./6/ProcTHOR-Train-4957.scene_instance.json", + "./6/ProcTHOR-Train-4281.scene_instance.json", + "./6/ProcTHOR-Train-4967.scene_instance.json", + "./6/ProcTHOR-Train-4938.scene_instance.json", + "./6/ProcTHOR-Train-4464.scene_instance.json", + "./6/ProcTHOR-Train-4427.scene_instance.json", + "./6/ProcTHOR-Train-4095.scene_instance.json", + "./6/ProcTHOR-Train-4023.scene_instance.json", + "./6/ProcTHOR-Train-4808.scene_instance.json", + "./6/ProcTHOR-Train-4537.scene_instance.json", + "./6/ProcTHOR-Train-4661.scene_instance.json", + "./6/ProcTHOR-Train-4277.scene_instance.json", + "./6/ProcTHOR-Train-4647.scene_instance.json", + "./6/ProcTHOR-Train-4908.scene_instance.json", + "./6/ProcTHOR-Train-4910.scene_instance.json", + "./6/ProcTHOR-Train-4121.scene_instance.json", + "./6/ProcTHOR-Train-4448.scene_instance.json", + "./6/ProcTHOR-Train-4741.scene_instance.json", + "./6/ProcTHOR-Train-4750.scene_instance.json", + "./6/ProcTHOR-Train-4617.scene_instance.json", + "./6/ProcTHOR-Train-4780.scene_instance.json", + "./6/ProcTHOR-Train-4246.scene_instance.json", + "./6/ProcTHOR-Train-4611.scene_instance.json", + "./6/ProcTHOR-Train-4405.scene_instance.json", + "./6/ProcTHOR-Train-4204.scene_instance.json", + "./6/ProcTHOR-Train-4323.scene_instance.json", + "./6/ProcTHOR-Train-4683.scene_instance.json", + "./6/ProcTHOR-Train-4181.scene_instance.json", + "./6/ProcTHOR-Train-4560.scene_instance.json", + "./6/ProcTHOR-Train-4315.scene_instance.json", + "./6/ProcTHOR-Train-4335.scene_instance.json", + "./6/ProcTHOR-Train-4826.scene_instance.json", + "./6/ProcTHOR-Train-4713.scene_instance.json", + "./6/ProcTHOR-Train-4914.scene_instance.json", + "./6/ProcTHOR-Train-4434.scene_instance.json", + "./6/ProcTHOR-Train-4887.scene_instance.json", + "./6/ProcTHOR-Train-4097.scene_instance.json", + "./6/ProcTHOR-Train-4800.scene_instance.json", + "./6/ProcTHOR-Train-4091.scene_instance.json", + "./6/ProcTHOR-Train-4630.scene_instance.json", + "./6/ProcTHOR-Train-4165.scene_instance.json", + "./6/ProcTHOR-Train-4089.scene_instance.json", + "./6/ProcTHOR-Train-4685.scene_instance.json", + "./6/ProcTHOR-Train-4010.scene_instance.json", + "./6/ProcTHOR-Train-4707.scene_instance.json", + "./6/ProcTHOR-Train-4878.scene_instance.json", + "./6/ProcTHOR-Train-4755.scene_instance.json", + "./6/ProcTHOR-Train-4525.scene_instance.json", + "./6/ProcTHOR-Train-4783.scene_instance.json", + "./6/ProcTHOR-Train-4621.scene_instance.json", + "./6/ProcTHOR-Train-4493.scene_instance.json", + "./6/ProcTHOR-Train-4407.scene_instance.json", + "./6/ProcTHOR-Train-4374.scene_instance.json", + "./6/ProcTHOR-Train-4937.scene_instance.json", + "./6/ProcTHOR-Train-4410.scene_instance.json", + "./6/ProcTHOR-Train-4209.scene_instance.json", + "./6/ProcTHOR-Train-4814.scene_instance.json", + "./6/ProcTHOR-Train-4368.scene_instance.json", + "./6/ProcTHOR-Train-4573.scene_instance.json", + "./6/ProcTHOR-Train-4549.scene_instance.json", + "./6/ProcTHOR-Train-4017.scene_instance.json", + "./6/ProcTHOR-Train-4714.scene_instance.json", + "./6/ProcTHOR-Train-4777.scene_instance.json", + "./6/ProcTHOR-Train-4635.scene_instance.json", + "./6/ProcTHOR-Train-4813.scene_instance.json", + "./6/ProcTHOR-Train-4909.scene_instance.json", + "./6/ProcTHOR-Train-4360.scene_instance.json", + "./6/ProcTHOR-Train-4512.scene_instance.json", + "./6/ProcTHOR-Train-4700.scene_instance.json", + "./6/ProcTHOR-Train-4995.scene_instance.json", + "./6/ProcTHOR-Train-4911.scene_instance.json", + "./6/ProcTHOR-Train-4822.scene_instance.json", + "./6/ProcTHOR-Train-4417.scene_instance.json", + "./6/ProcTHOR-Train-4432.scene_instance.json", + "./6/ProcTHOR-Train-4732.scene_instance.json", + "./6/ProcTHOR-Train-4006.scene_instance.json", + "./6/ProcTHOR-Train-4231.scene_instance.json", + "./6/ProcTHOR-Train-4355.scene_instance.json", + "./6/ProcTHOR-Train-4302.scene_instance.json", + "./6/ProcTHOR-Train-4472.scene_instance.json", + "./6/ProcTHOR-Train-4886.scene_instance.json", + "./6/ProcTHOR-Train-4345.scene_instance.json", + "./6/ProcTHOR-Train-4035.scene_instance.json", + "./6/ProcTHOR-Train-4862.scene_instance.json", + "./6/ProcTHOR-Train-4079.scene_instance.json", + "./6/ProcTHOR-Train-4107.scene_instance.json", + "./6/ProcTHOR-Train-4070.scene_instance.json", + "./6/ProcTHOR-Train-4831.scene_instance.json", + "./6/ProcTHOR-Train-4563.scene_instance.json", + "./6/ProcTHOR-Train-4274.scene_instance.json", + "./6/ProcTHOR-Train-4767.scene_instance.json", + "./6/ProcTHOR-Train-4106.scene_instance.json", + "./6/ProcTHOR-Train-4227.scene_instance.json", + "./6/ProcTHOR-Train-4331.scene_instance.json", + "./6/ProcTHOR-Train-4207.scene_instance.json", + "./6/ProcTHOR-Train-4081.scene_instance.json", + "./6/ProcTHOR-Train-4419.scene_instance.json", + "./6/ProcTHOR-Train-4054.scene_instance.json", + "./6/ProcTHOR-Train-4036.scene_instance.json", + "./6/ProcTHOR-Train-4252.scene_instance.json", + "./6/ProcTHOR-Train-4598.scene_instance.json", + "./6/ProcTHOR-Train-4373.scene_instance.json", + "./6/ProcTHOR-Train-4541.scene_instance.json", + "./6/ProcTHOR-Train-4282.scene_instance.json", + "./6/ProcTHOR-Train-4329.scene_instance.json", + "./6/ProcTHOR-Train-4597.scene_instance.json", + "./6/ProcTHOR-Train-4646.scene_instance.json", + "./6/ProcTHOR-Train-4881.scene_instance.json", + "./6/ProcTHOR-Train-4476.scene_instance.json", + "./6/ProcTHOR-Train-4004.scene_instance.json", + "./6/ProcTHOR-Train-4726.scene_instance.json", + "./6/ProcTHOR-Train-4764.scene_instance.json", + "./6/ProcTHOR-Train-4262.scene_instance.json", + "./6/ProcTHOR-Train-4883.scene_instance.json", + "./6/ProcTHOR-Train-4694.scene_instance.json", + "./6/ProcTHOR-Train-4971.scene_instance.json", + "./6/ProcTHOR-Train-4488.scene_instance.json", + "./6/ProcTHOR-Train-4527.scene_instance.json", + "./6/ProcTHOR-Train-4927.scene_instance.json", + "./6/ProcTHOR-Train-4645.scene_instance.json", + "./6/ProcTHOR-Train-4152.scene_instance.json", + "./6/ProcTHOR-Train-4931.scene_instance.json", + "./6/ProcTHOR-Train-4828.scene_instance.json", + "./6/ProcTHOR-Train-4965.scene_instance.json", + "./6/ProcTHOR-Train-4631.scene_instance.json", + "./6/ProcTHOR-Train-4833.scene_instance.json", + "./6/ProcTHOR-Train-4175.scene_instance.json", + "./6/ProcTHOR-Train-4015.scene_instance.json", + "./6/ProcTHOR-Train-4851.scene_instance.json", + "./6/ProcTHOR-Train-4580.scene_instance.json", + "./6/ProcTHOR-Train-4861.scene_instance.json", + "./6/ProcTHOR-Train-4256.scene_instance.json", + "./6/ProcTHOR-Train-4657.scene_instance.json", + "./6/ProcTHOR-Train-4712.scene_instance.json", + "./6/ProcTHOR-Train-4378.scene_instance.json", + "./6/ProcTHOR-Train-4997.scene_instance.json", + "./6/ProcTHOR-Train-4071.scene_instance.json", + "./6/ProcTHOR-Train-4507.scene_instance.json", + "./6/ProcTHOR-Train-4592.scene_instance.json", + "./6/ProcTHOR-Train-4321.scene_instance.json", + "./6/ProcTHOR-Train-4153.scene_instance.json", + "./6/ProcTHOR-Train-4610.scene_instance.json", + "./6/ProcTHOR-Train-4856.scene_instance.json", + "./6/ProcTHOR-Train-4906.scene_instance.json", + "./6/ProcTHOR-Train-4596.scene_instance.json", + "./6/ProcTHOR-Train-4571.scene_instance.json", + "./6/ProcTHOR-Train-4250.scene_instance.json", + "./6/ProcTHOR-Train-4027.scene_instance.json", + "./6/ProcTHOR-Train-4237.scene_instance.json", + "./6/ProcTHOR-Train-4114.scene_instance.json", + "./6/ProcTHOR-Train-4487.scene_instance.json", + "./6/ProcTHOR-Train-4842.scene_instance.json", + "./6/ProcTHOR-Train-4443.scene_instance.json", + "./6/ProcTHOR-Train-4765.scene_instance.json", + "./6/ProcTHOR-Train-4225.scene_instance.json", + "./6/ProcTHOR-Train-4774.scene_instance.json", + "./6/ProcTHOR-Train-4069.scene_instance.json", + "./6/ProcTHOR-Train-4290.scene_instance.json", + "./6/ProcTHOR-Train-4348.scene_instance.json", + "./6/ProcTHOR-Train-4614.scene_instance.json", + "./6/ProcTHOR-Train-4296.scene_instance.json", + "./6/ProcTHOR-Train-4548.scene_instance.json", + "./6/ProcTHOR-Train-4061.scene_instance.json", + "./6/ProcTHOR-Train-4392.scene_instance.json", + "./6/ProcTHOR-Train-4076.scene_instance.json", + "./6/ProcTHOR-Train-4641.scene_instance.json", + "./6/ProcTHOR-Train-4839.scene_instance.json", + "./6/ProcTHOR-Train-4534.scene_instance.json", + "./6/ProcTHOR-Train-4135.scene_instance.json", + "./6/ProcTHOR-Train-4369.scene_instance.json", + "./6/ProcTHOR-Train-4730.scene_instance.json", + "./6/ProcTHOR-Train-4320.scene_instance.json", + "./6/ProcTHOR-Train-4343.scene_instance.json", + "./6/ProcTHOR-Train-4138.scene_instance.json", + "./6/ProcTHOR-Train-4195.scene_instance.json", + "./6/ProcTHOR-Train-4706.scene_instance.json", + "./6/ProcTHOR-Train-4622.scene_instance.json", + "./6/ProcTHOR-Train-4536.scene_instance.json", + "./6/ProcTHOR-Train-4556.scene_instance.json", + "./6/ProcTHOR-Train-4753.scene_instance.json", + "./6/ProcTHOR-Train-4009.scene_instance.json", + "./6/ProcTHOR-Train-4830.scene_instance.json", + "./6/ProcTHOR-Train-4873.scene_instance.json", + "./6/ProcTHOR-Train-4787.scene_instance.json", + "./6/ProcTHOR-Train-4390.scene_instance.json", + "./6/ProcTHOR-Train-4357.scene_instance.json", + "./6/ProcTHOR-Train-4558.scene_instance.json", + "./6/ProcTHOR-Train-4108.scene_instance.json", + "./6/ProcTHOR-Train-4383.scene_instance.json", + "./6/ProcTHOR-Train-4590.scene_instance.json", + "./6/ProcTHOR-Train-4978.scene_instance.json", + "./6/ProcTHOR-Train-4771.scene_instance.json", + "./6/ProcTHOR-Train-4576.scene_instance.json", + "./6/ProcTHOR-Train-4283.scene_instance.json", + "./6/ProcTHOR-Train-4954.scene_instance.json", + "./6/ProcTHOR-Train-4552.scene_instance.json", + "./6/ProcTHOR-Train-4047.scene_instance.json", + "./6/ProcTHOR-Train-4314.scene_instance.json", + "./6/ProcTHOR-Train-4951.scene_instance.json", + "./6/ProcTHOR-Train-4126.scene_instance.json", + "./6/ProcTHOR-Train-4112.scene_instance.json", + "./6/ProcTHOR-Train-4264.scene_instance.json", + "./6/ProcTHOR-Train-4575.scene_instance.json", + "./6/ProcTHOR-Train-4495.scene_instance.json", + "./6/ProcTHOR-Train-4219.scene_instance.json", + "./6/ProcTHOR-Train-4295.scene_instance.json", + "./6/ProcTHOR-Train-4928.scene_instance.json", + "./6/ProcTHOR-Train-4318.scene_instance.json", + "./6/ProcTHOR-Train-4206.scene_instance.json", + "./6/ProcTHOR-Train-4075.scene_instance.json", + "./6/ProcTHOR-Train-4693.scene_instance.json", + "./6/ProcTHOR-Train-4055.scene_instance.json", + "./6/ProcTHOR-Train-4032.scene_instance.json", + "./6/ProcTHOR-Train-4020.scene_instance.json", + "./6/ProcTHOR-Train-4606.scene_instance.json", + "./6/ProcTHOR-Train-4526.scene_instance.json", + "./6/ProcTHOR-Train-4389.scene_instance.json", + "./6/ProcTHOR-Train-4577.scene_instance.json", + "./6/ProcTHOR-Train-4467.scene_instance.json", + "./6/ProcTHOR-Train-4139.scene_instance.json", + "./6/ProcTHOR-Train-4308.scene_instance.json", + "./6/ProcTHOR-Train-4267.scene_instance.json", + "./6/ProcTHOR-Train-4897.scene_instance.json", + "./6/ProcTHOR-Train-4505.scene_instance.json", + "./6/ProcTHOR-Train-4008.scene_instance.json", + "./6/ProcTHOR-Train-4969.scene_instance.json", + "./6/ProcTHOR-Train-4157.scene_instance.json", + "./6/ProcTHOR-Train-4234.scene_instance.json", + "./6/ProcTHOR-Train-4502.scene_instance.json", + "./6/ProcTHOR-Train-4653.scene_instance.json", + "./6/ProcTHOR-Train-4516.scene_instance.json", + "./6/ProcTHOR-Train-4340.scene_instance.json", + "./6/ProcTHOR-Train-4211.scene_instance.json", + "./6/ProcTHOR-Train-4894.scene_instance.json", + "./6/ProcTHOR-Train-4458.scene_instance.json", + "./6/ProcTHOR-Train-4841.scene_instance.json", + "./6/ProcTHOR-Train-4469.scene_instance.json", + "./6/ProcTHOR-Train-4985.scene_instance.json", + "./6/ProcTHOR-Train-4416.scene_instance.json", + "./6/ProcTHOR-Train-4736.scene_instance.json", + "./6/ProcTHOR-Train-4889.scene_instance.json", + "./6/ProcTHOR-Train-4776.scene_instance.json", + "./6/ProcTHOR-Train-4087.scene_instance.json", + "./6/ProcTHOR-Train-4827.scene_instance.json", + "./6/ProcTHOR-Train-4651.scene_instance.json", + "./6/ProcTHOR-Train-4589.scene_instance.json", + "./6/ProcTHOR-Train-4223.scene_instance.json", + "./6/ProcTHOR-Train-4743.scene_instance.json", + "./6/ProcTHOR-Train-4453.scene_instance.json", + "./6/ProcTHOR-Train-4721.scene_instance.json", + "./6/ProcTHOR-Train-4847.scene_instance.json", + "./6/ProcTHOR-Train-4304.scene_instance.json", + "./6/ProcTHOR-Train-4935.scene_instance.json", + "./6/ProcTHOR-Train-4518.scene_instance.json", + "./6/ProcTHOR-Train-4907.scene_instance.json", + "./6/ProcTHOR-Train-4547.scene_instance.json", + "./6/ProcTHOR-Train-4074.scene_instance.json", + "./6/ProcTHOR-Train-4678.scene_instance.json", + "./6/ProcTHOR-Train-4429.scene_instance.json", + "./6/ProcTHOR-Train-4874.scene_instance.json", + "./6/ProcTHOR-Train-4485.scene_instance.json", + "./6/ProcTHOR-Train-4956.scene_instance.json", + "./6/ProcTHOR-Train-4173.scene_instance.json", + "./6/ProcTHOR-Train-4341.scene_instance.json", + "./6/ProcTHOR-Train-4836.scene_instance.json", + "./6/ProcTHOR-Train-4028.scene_instance.json", + "./6/ProcTHOR-Train-4959.scene_instance.json", + "./6/ProcTHOR-Train-4280.scene_instance.json", + "./6/ProcTHOR-Train-4591.scene_instance.json", + "./6/ProcTHOR-Train-4981.scene_instance.json", + "./6/ProcTHOR-Train-4899.scene_instance.json", + "./6/ProcTHOR-Train-4381.scene_instance.json", + "./6/ProcTHOR-Train-4652.scene_instance.json", + "./6/ProcTHOR-Train-4412.scene_instance.json", + "./6/ProcTHOR-Train-4242.scene_instance.json", + "./6/ProcTHOR-Train-4465.scene_instance.json", + "./6/ProcTHOR-Train-4384.scene_instance.json", + "./6/ProcTHOR-Train-4623.scene_instance.json", + "./6/ProcTHOR-Train-4943.scene_instance.json", + "./6/ProcTHOR-Train-4322.scene_instance.json", + "./6/ProcTHOR-Train-4142.scene_instance.json", + "./6/ProcTHOR-Train-4843.scene_instance.json", + "./6/ProcTHOR-Train-4947.scene_instance.json", + "./6/ProcTHOR-Train-4116.scene_instance.json", + "./6/ProcTHOR-Train-4038.scene_instance.json", + "./6/ProcTHOR-Train-4222.scene_instance.json", + "./6/ProcTHOR-Train-4961.scene_instance.json", + "./6/ProcTHOR-Train-4243.scene_instance.json", + "./6/ProcTHOR-Train-4673.scene_instance.json", + "./6/ProcTHOR-Train-4834.scene_instance.json", + "./6/ProcTHOR-Train-4276.scene_instance.json", + "./6/ProcTHOR-Train-4447.scene_instance.json", + "./6/ProcTHOR-Train-4454.scene_instance.json", + "./6/ProcTHOR-Train-4418.scene_instance.json", + "./6/ProcTHOR-Train-4718.scene_instance.json", + "./6/ProcTHOR-Train-4864.scene_instance.json", + "./6/ProcTHOR-Train-4059.scene_instance.json", + "./6/ProcTHOR-Train-4643.scene_instance.json", + "./6/ProcTHOR-Train-4770.scene_instance.json", + "./6/ProcTHOR-Train-4902.scene_instance.json", + "./6/ProcTHOR-Train-4769.scene_instance.json", + "./6/ProcTHOR-Train-4349.scene_instance.json", + "./6/ProcTHOR-Train-4210.scene_instance.json", + "./6/ProcTHOR-Train-4271.scene_instance.json", + "./6/ProcTHOR-Train-4399.scene_instance.json", + "./6/ProcTHOR-Train-4696.scene_instance.json", + "./6/ProcTHOR-Train-4147.scene_instance.json", + "./6/ProcTHOR-Train-4085.scene_instance.json", + "./6/ProcTHOR-Train-4566.scene_instance.json", + "./6/ProcTHOR-Train-4287.scene_instance.json", + "./6/ProcTHOR-Train-4294.scene_instance.json", + "./6/ProcTHOR-Train-4605.scene_instance.json", + "./6/ProcTHOR-Train-4895.scene_instance.json", + "./6/ProcTHOR-Train-4821.scene_instance.json", + "./6/ProcTHOR-Train-4687.scene_instance.json", + "./6/ProcTHOR-Train-4137.scene_instance.json", + "./6/ProcTHOR-Train-4228.scene_instance.json", + "./6/ProcTHOR-Train-4970.scene_instance.json", + "./6/ProcTHOR-Train-4748.scene_instance.json", + "./6/ProcTHOR-Train-4778.scene_instance.json", + "./6/ProcTHOR-Train-4819.scene_instance.json", + "./6/ProcTHOR-Train-4720.scene_instance.json", + "./6/ProcTHOR-Train-4269.scene_instance.json", + "./6/ProcTHOR-Train-4214.scene_instance.json", + "./6/ProcTHOR-Train-4532.scene_instance.json", + "./6/ProcTHOR-Train-4901.scene_instance.json", + "./6/ProcTHOR-Train-4628.scene_instance.json", + "./6/ProcTHOR-Train-4569.scene_instance.json", + "./6/ProcTHOR-Train-4406.scene_instance.json", + "./6/ProcTHOR-Train-4203.scene_instance.json", + "./6/ProcTHOR-Train-4968.scene_instance.json", + "./6/ProcTHOR-Train-4763.scene_instance.json", + "./6/ProcTHOR-Train-4078.scene_instance.json", + "./6/ProcTHOR-Train-4067.scene_instance.json", + "./6/ProcTHOR-Train-4167.scene_instance.json", + "./6/ProcTHOR-Train-4616.scene_instance.json", + "./6/ProcTHOR-Train-4554.scene_instance.json", + "./6/ProcTHOR-Train-4849.scene_instance.json", + "./6/ProcTHOR-Train-4919.scene_instance.json", + "./6/ProcTHOR-Train-4292.scene_instance.json", + "./6/ProcTHOR-Train-4481.scene_instance.json", + "./6/ProcTHOR-Train-4486.scene_instance.json", + "./6/ProcTHOR-Train-4739.scene_instance.json", + "./6/ProcTHOR-Train-4797.scene_instance.json", + "./6/ProcTHOR-Train-4872.scene_instance.json", + "./6/ProcTHOR-Train-4436.scene_instance.json", + "./6/ProcTHOR-Train-4253.scene_instance.json", + "./6/ProcTHOR-Train-4182.scene_instance.json", + "./6/ProcTHOR-Train-4177.scene_instance.json", + "./6/ProcTHOR-Train-4941.scene_instance.json", + "./6/ProcTHOR-Train-4084.scene_instance.json", + "./6/ProcTHOR-Train-4815.scene_instance.json", + "./6/ProcTHOR-Train-4522.scene_instance.json", + "./6/ProcTHOR-Train-4946.scene_instance.json", + "./6/ProcTHOR-Train-4333.scene_instance.json", + "./6/ProcTHOR-Train-4230.scene_instance.json", + "./6/ProcTHOR-Train-4517.scene_instance.json", + "./6/ProcTHOR-Train-4913.scene_instance.json", + "./6/ProcTHOR-Train-4444.scene_instance.json", + "./6/ProcTHOR-Train-4397.scene_instance.json", + "./6/ProcTHOR-Train-4877.scene_instance.json", + "./6/ProcTHOR-Train-4860.scene_instance.json", + "./6/ProcTHOR-Train-4102.scene_instance.json", + "./6/ProcTHOR-Train-4279.scene_instance.json", + "./6/ProcTHOR-Train-4649.scene_instance.json", + "./6/ProcTHOR-Train-4297.scene_instance.json", + "./6/ProcTHOR-Train-4336.scene_instance.json", + "./6/ProcTHOR-Train-4785.scene_instance.json", + "./6/ProcTHOR-Train-4775.scene_instance.json", + "./6/ProcTHOR-Train-4686.scene_instance.json", + "./6/ProcTHOR-Train-4334.scene_instance.json", + "./6/ProcTHOR-Train-4514.scene_instance.json", + "./6/ProcTHOR-Train-4093.scene_instance.json", + "./6/ProcTHOR-Train-4342.scene_instance.json", + "./6/ProcTHOR-Train-4975.scene_instance.json", + "./6/ProcTHOR-Train-4682.scene_instance.json", + "./6/ProcTHOR-Train-4413.scene_instance.json", + "./6/ProcTHOR-Train-4987.scene_instance.json", + "./6/ProcTHOR-Train-4058.scene_instance.json", + "./6/ProcTHOR-Train-4477.scene_instance.json", + "./6/ProcTHOR-Train-4307.scene_instance.json", + "./6/ProcTHOR-Train-4865.scene_instance.json", + "./6/ProcTHOR-Train-4030.scene_instance.json", + "./6/ProcTHOR-Train-4638.scene_instance.json", + "./6/ProcTHOR-Train-4421.scene_instance.json", + "./6/ProcTHOR-Train-4012.scene_instance.json", + "./6/ProcTHOR-Train-4866.scene_instance.json", + "./6/ProcTHOR-Train-4224.scene_instance.json", + "./6/ProcTHOR-Train-4065.scene_instance.json", + "./6/ProcTHOR-Train-4582.scene_instance.json", + "./6/ProcTHOR-Train-4790.scene_instance.json", + "./6/ProcTHOR-Train-4319.scene_instance.json", + "./6/ProcTHOR-Train-4394.scene_instance.json", + "./6/ProcTHOR-Train-4199.scene_instance.json", + "./6/ProcTHOR-Train-4994.scene_instance.json", + "./6/ProcTHOR-Train-4751.scene_instance.json", + "./6/ProcTHOR-Train-4760.scene_instance.json", + "./6/ProcTHOR-Train-4882.scene_instance.json", + "./6/ProcTHOR-Train-4428.scene_instance.json", + "./6/ProcTHOR-Train-4229.scene_instance.json", + "./6/ProcTHOR-Train-4562.scene_instance.json", + "./6/ProcTHOR-Train-4241.scene_instance.json", + "./6/ProcTHOR-Train-4484.scene_instance.json", + "./6/ProcTHOR-Train-4001.scene_instance.json", + "./6/ProcTHOR-Train-4740.scene_instance.json", + "./6/ProcTHOR-Train-4249.scene_instance.json", + "./6/ProcTHOR-Train-4449.scene_instance.json", + "./6/ProcTHOR-Train-4708.scene_instance.json", + "./6/ProcTHOR-Train-4456.scene_instance.json", + "./6/ProcTHOR-Train-4867.scene_instance.json", + "./6/ProcTHOR-Train-4172.scene_instance.json", + "./6/ProcTHOR-Train-4039.scene_instance.json", + "./6/ProcTHOR-Train-4344.scene_instance.json", + "./6/ProcTHOR-Train-4607.scene_instance.json", + "./6/ProcTHOR-Train-4840.scene_instance.json", + "./6/ProcTHOR-Train-4491.scene_instance.json", + "./6/ProcTHOR-Train-4362.scene_instance.json", + "./6/ProcTHOR-Train-4024.scene_instance.json", + "./6/ProcTHOR-Train-4197.scene_instance.json", + "./6/ProcTHOR-Train-4375.scene_instance.json", + "./6/ProcTHOR-Train-4723.scene_instance.json", + "./6/ProcTHOR-Train-4601.scene_instance.json", + "./6/ProcTHOR-Train-4654.scene_instance.json", + "./6/ProcTHOR-Train-4096.scene_instance.json", + "./6/ProcTHOR-Train-4364.scene_instance.json", + "./6/ProcTHOR-Train-4677.scene_instance.json", + "./6/ProcTHOR-Train-4809.scene_instance.json", + "./6/ProcTHOR-Train-4361.scene_instance.json", + "./6/ProcTHOR-Train-4092.scene_instance.json", + "./6/ProcTHOR-Train-4240.scene_instance.json", + "./6/ProcTHOR-Train-4917.scene_instance.json", + "./6/ProcTHOR-Train-4411.scene_instance.json", + "./6/ProcTHOR-Train-4154.scene_instance.json", + "./6/ProcTHOR-Train-4393.scene_instance.json", + "./6/ProcTHOR-Train-4445.scene_instance.json", + "./6/ProcTHOR-Train-4858.scene_instance.json", + "./6/ProcTHOR-Train-4068.scene_instance.json", + "./6/ProcTHOR-Train-4664.scene_instance.json", + "./6/ProcTHOR-Train-4498.scene_instance.json", + "./6/ProcTHOR-Train-4104.scene_instance.json", + "./6/ProcTHOR-Train-4738.scene_instance.json", + "./6/ProcTHOR-Train-4676.scene_instance.json", + "./6/ProcTHOR-Train-4359.scene_instance.json", + "./6/ProcTHOR-Train-4426.scene_instance.json", + "./6/ProcTHOR-Train-4793.scene_instance.json", + "./6/ProcTHOR-Train-4029.scene_instance.json", + "./1/ProcTHOR-Test-479.scene_instance.json", + "./1/ProcTHOR-Test-112.scene_instance.json", + "./1/ProcTHOR-Test-570.scene_instance.json", + "./1/ProcTHOR-Test-328.scene_instance.json", + "./1/ProcTHOR-Test-711.scene_instance.json", + "./1/ProcTHOR-Test-572.scene_instance.json", + "./1/ProcTHOR-Test-208.scene_instance.json", + "./1/ProcTHOR-Test-414.scene_instance.json", + "./1/ProcTHOR-Test-602.scene_instance.json", + "./1/ProcTHOR-Test-16.scene_instance.json", + "./1/ProcTHOR-Test-80.scene_instance.json", + "./1/ProcTHOR-Test-952.scene_instance.json", + "./1/ProcTHOR-Test-372.scene_instance.json", + "./1/ProcTHOR-Test-694.scene_instance.json", + "./1/ProcTHOR-Test-878.scene_instance.json", + "./1/ProcTHOR-Test-181.scene_instance.json", + "./1/ProcTHOR-Test-192.scene_instance.json", + "./1/ProcTHOR-Test-764.scene_instance.json", + "./1/ProcTHOR-Test-865.scene_instance.json", + "./1/ProcTHOR-Test-778.scene_instance.json", + "./1/ProcTHOR-Test-687.scene_instance.json", + "./1/ProcTHOR-Test-78.scene_instance.json", + "./1/ProcTHOR-Test-775.scene_instance.json", + "./1/ProcTHOR-Test-43.scene_instance.json", + "./1/ProcTHOR-Test-108.scene_instance.json", + "./1/ProcTHOR-Test-720.scene_instance.json", + "./1/ProcTHOR-Test-896.scene_instance.json", + "./1/ProcTHOR-Test-788.scene_instance.json", + "./1/ProcTHOR-Test-121.scene_instance.json", + "./1/ProcTHOR-Test-265.scene_instance.json", + "./1/ProcTHOR-Test-651.scene_instance.json", + "./1/ProcTHOR-Test-621.scene_instance.json", + "./1/ProcTHOR-Test-407.scene_instance.json", + "./1/ProcTHOR-Test-153.scene_instance.json", + "./1/ProcTHOR-Test-378.scene_instance.json", + "./1/ProcTHOR-Test-467.scene_instance.json", + "./1/ProcTHOR-Test-488.scene_instance.json", + "./1/ProcTHOR-Test-126.scene_instance.json", + "./1/ProcTHOR-Test-390.scene_instance.json", + "./1/ProcTHOR-Test-170.scene_instance.json", + "./1/ProcTHOR-Test-222.scene_instance.json", + "./1/ProcTHOR-Test-499.scene_instance.json", + "./1/ProcTHOR-Test-180.scene_instance.json", + "./1/ProcTHOR-Test-632.scene_instance.json", + "./1/ProcTHOR-Test-436.scene_instance.json", + "./1/ProcTHOR-Test-625.scene_instance.json", + "./1/ProcTHOR-Test-812.scene_instance.json", + "./1/ProcTHOR-Test-910.scene_instance.json", + "./1/ProcTHOR-Test-721.scene_instance.json", + "./1/ProcTHOR-Test-26.scene_instance.json", + "./1/ProcTHOR-Test-907.scene_instance.json", + "./1/ProcTHOR-Test-517.scene_instance.json", + "./1/ProcTHOR-Test-345.scene_instance.json", + "./1/ProcTHOR-Test-359.scene_instance.json", + "./1/ProcTHOR-Test-887.scene_instance.json", + "./1/ProcTHOR-Test-684.scene_instance.json", + "./1/ProcTHOR-Test-248.scene_instance.json", + "./1/ProcTHOR-Test-539.scene_instance.json", + "./1/ProcTHOR-Test-432.scene_instance.json", + "./1/ProcTHOR-Test-292.scene_instance.json", + "./1/ProcTHOR-Test-495.scene_instance.json", + "./1/ProcTHOR-Test-519.scene_instance.json", + "./1/ProcTHOR-Test-654.scene_instance.json", + "./1/ProcTHOR-Test-618.scene_instance.json", + "./1/ProcTHOR-Test-643.scene_instance.json", + "./1/ProcTHOR-Test-534.scene_instance.json", + "./1/ProcTHOR-Test-998.scene_instance.json", + "./1/ProcTHOR-Test-421.scene_instance.json", + "./1/ProcTHOR-Test-256.scene_instance.json", + "./1/ProcTHOR-Test-879.scene_instance.json", + "./1/ProcTHOR-Test-175.scene_instance.json", + "./1/ProcTHOR-Test-607.scene_instance.json", + "./1/ProcTHOR-Test-86.scene_instance.json", + "./1/ProcTHOR-Test-193.scene_instance.json", + "./1/ProcTHOR-Test-932.scene_instance.json", + "./1/ProcTHOR-Test-134.scene_instance.json", + "./1/ProcTHOR-Test-416.scene_instance.json", + "./1/ProcTHOR-Test-129.scene_instance.json", + "./1/ProcTHOR-Test-736.scene_instance.json", + "./1/ProcTHOR-Test-410.scene_instance.json", + "./1/ProcTHOR-Test-327.scene_instance.json", + "./1/ProcTHOR-Test-582.scene_instance.json", + "./1/ProcTHOR-Test-45.scene_instance.json", + "./1/ProcTHOR-Test-443.scene_instance.json", + "./1/ProcTHOR-Test-197.scene_instance.json", + "./1/ProcTHOR-Test-199.scene_instance.json", + "./1/ProcTHOR-Test-360.scene_instance.json", + "./1/ProcTHOR-Test-653.scene_instance.json", + "./1/ProcTHOR-Test-733.scene_instance.json", + "./1/ProcTHOR-Test-577.scene_instance.json", + "./1/ProcTHOR-Test-931.scene_instance.json", + "./1/ProcTHOR-Test-284.scene_instance.json", + "./1/ProcTHOR-Test-457.scene_instance.json", + "./1/ProcTHOR-Test-386.scene_instance.json", + "./1/ProcTHOR-Test-669.scene_instance.json", + "./1/ProcTHOR-Test-847.scene_instance.json", + "./1/ProcTHOR-Test-264.scene_instance.json", + "./1/ProcTHOR-Test-492.scene_instance.json", + "./1/ProcTHOR-Test-354.scene_instance.json", + "./1/ProcTHOR-Test-450.scene_instance.json", + "./1/ProcTHOR-Test-477.scene_instance.json", + "./1/ProcTHOR-Test-21.scene_instance.json", + "./1/ProcTHOR-Test-738.scene_instance.json", + "./1/ProcTHOR-Test-666.scene_instance.json", + "./1/ProcTHOR-Test-83.scene_instance.json", + "./1/ProcTHOR-Test-334.scene_instance.json", + "./1/ProcTHOR-Test-302.scene_instance.json", + "./1/ProcTHOR-Test-65.scene_instance.json", + "./1/ProcTHOR-Test-293.scene_instance.json", + "./1/ProcTHOR-Test-610.scene_instance.json", + "./1/ProcTHOR-Test-169.scene_instance.json", + "./1/ProcTHOR-Test-392.scene_instance.json", + "./1/ProcTHOR-Test-497.scene_instance.json", + "./1/ProcTHOR-Test-491.scene_instance.json", + "./1/ProcTHOR-Test-624.scene_instance.json", + "./1/ProcTHOR-Test-1.scene_instance.json", + "./1/ProcTHOR-Test-283.scene_instance.json", + "./1/ProcTHOR-Test-934.scene_instance.json", + "./1/ProcTHOR-Test-802.scene_instance.json", + "./1/ProcTHOR-Test-974.scene_instance.json", + "./1/ProcTHOR-Test-115.scene_instance.json", + "./1/ProcTHOR-Test-374.scene_instance.json", + "./1/ProcTHOR-Test-843.scene_instance.json", + "./1/ProcTHOR-Test-60.scene_instance.json", + "./1/ProcTHOR-Test-623.scene_instance.json", + "./1/ProcTHOR-Test-552.scene_instance.json", + "./1/ProcTHOR-Test-560.scene_instance.json", + "./1/ProcTHOR-Test-104.scene_instance.json", + "./1/ProcTHOR-Test-379.scene_instance.json", + "./1/ProcTHOR-Test-40.scene_instance.json", + "./1/ProcTHOR-Test-282.scene_instance.json", + "./1/ProcTHOR-Test-709.scene_instance.json", + "./1/ProcTHOR-Test-316.scene_instance.json", + "./1/ProcTHOR-Test-591.scene_instance.json", + "./1/ProcTHOR-Test-267.scene_instance.json", + "./1/ProcTHOR-Test-832.scene_instance.json", + "./1/ProcTHOR-Test-726.scene_instance.json", + "./1/ProcTHOR-Test-200.scene_instance.json", + "./1/ProcTHOR-Test-313.scene_instance.json", + "./1/ProcTHOR-Test-917.scene_instance.json", + "./1/ProcTHOR-Test-786.scene_instance.json", + "./1/ProcTHOR-Test-318.scene_instance.json", + "./1/ProcTHOR-Test-817.scene_instance.json", + "./1/ProcTHOR-Test-4.scene_instance.json", + "./1/ProcTHOR-Test-696.scene_instance.json", + "./1/ProcTHOR-Test-429.scene_instance.json", + "./1/ProcTHOR-Test-500.scene_instance.json", + "./1/ProcTHOR-Test-0.scene_instance.json", + "./1/ProcTHOR-Test-357.scene_instance.json", + "./1/ProcTHOR-Test-231.scene_instance.json", + "./1/ProcTHOR-Test-38.scene_instance.json", + "./1/ProcTHOR-Test-409.scene_instance.json", + "./1/ProcTHOR-Test-100.scene_instance.json", + "./1/ProcTHOR-Test-343.scene_instance.json", + "./1/ProcTHOR-Test-637.scene_instance.json", + "./1/ProcTHOR-Test-716.scene_instance.json", + "./1/ProcTHOR-Test-845.scene_instance.json", + "./1/ProcTHOR-Test-834.scene_instance.json", + "./1/ProcTHOR-Test-828.scene_instance.json", + "./1/ProcTHOR-Test-569.scene_instance.json", + "./1/ProcTHOR-Test-369.scene_instance.json", + "./1/ProcTHOR-Test-105.scene_instance.json", + "./1/ProcTHOR-Test-476.scene_instance.json", + "./1/ProcTHOR-Test-933.scene_instance.json", + "./1/ProcTHOR-Test-820.scene_instance.json", + "./1/ProcTHOR-Test-821.scene_instance.json", + "./1/ProcTHOR-Test-626.scene_instance.json", + "./1/ProcTHOR-Test-99.scene_instance.json", + "./1/ProcTHOR-Test-184.scene_instance.json", + "./1/ProcTHOR-Test-612.scene_instance.json", + "./1/ProcTHOR-Test-718.scene_instance.json", + "./1/ProcTHOR-Test-994.scene_instance.json", + "./1/ProcTHOR-Test-507.scene_instance.json", + "./1/ProcTHOR-Test-159.scene_instance.json", + "./1/ProcTHOR-Test-304.scene_instance.json", + "./1/ProcTHOR-Test-836.scene_instance.json", + "./1/ProcTHOR-Test-505.scene_instance.json", + "./1/ProcTHOR-Test-962.scene_instance.json", + "./1/ProcTHOR-Test-141.scene_instance.json", + "./1/ProcTHOR-Test-274.scene_instance.json", + "./1/ProcTHOR-Test-928.scene_instance.json", + "./1/ProcTHOR-Test-807.scene_instance.json", + "./1/ProcTHOR-Test-446.scene_instance.json", + "./1/ProcTHOR-Test-24.scene_instance.json", + "./1/ProcTHOR-Test-240.scene_instance.json", + "./1/ProcTHOR-Test-251.scene_instance.json", + "./1/ProcTHOR-Test-916.scene_instance.json", + "./1/ProcTHOR-Test-968.scene_instance.json", + "./1/ProcTHOR-Test-332.scene_instance.json", + "./1/ProcTHOR-Test-581.scene_instance.json", + "./1/ProcTHOR-Test-571.scene_instance.json", + "./1/ProcTHOR-Test-947.scene_instance.json", + "./1/ProcTHOR-Test-680.scene_instance.json", + "./1/ProcTHOR-Test-856.scene_instance.json", + "./1/ProcTHOR-Test-19.scene_instance.json", + "./1/ProcTHOR-Test-426.scene_instance.json", + "./1/ProcTHOR-Test-85.scene_instance.json", + "./1/ProcTHOR-Test-363.scene_instance.json", + "./1/ProcTHOR-Test-995.scene_instance.json", + "./1/ProcTHOR-Test-937.scene_instance.json", + "./1/ProcTHOR-Test-393.scene_instance.json", + "./1/ProcTHOR-Test-833.scene_instance.json", + "./1/ProcTHOR-Test-667.scene_instance.json", + "./1/ProcTHOR-Test-399.scene_instance.json", + "./1/ProcTHOR-Test-411.scene_instance.json", + "./1/ProcTHOR-Test-216.scene_instance.json", + "./1/ProcTHOR-Test-289.scene_instance.json", + "./1/ProcTHOR-Test-52.scene_instance.json", + "./1/ProcTHOR-Test-810.scene_instance.json", + "./1/ProcTHOR-Test-458.scene_instance.json", + "./1/ProcTHOR-Test-515.scene_instance.json", + "./1/ProcTHOR-Test-272.scene_instance.json", + "./1/ProcTHOR-Test-329.scene_instance.json", + "./1/ProcTHOR-Test-461.scene_instance.json", + "./1/ProcTHOR-Test-811.scene_instance.json", + "./1/ProcTHOR-Test-768.scene_instance.json", + "./1/ProcTHOR-Test-355.scene_instance.json", + "./1/ProcTHOR-Test-655.scene_instance.json", + "./1/ProcTHOR-Test-690.scene_instance.json", + "./1/ProcTHOR-Test-439.scene_instance.json", + "./1/ProcTHOR-Test-489.scene_instance.json", + "./1/ProcTHOR-Test-511.scene_instance.json", + "./1/ProcTHOR-Test-584.scene_instance.json", + "./1/ProcTHOR-Test-562.scene_instance.json", + "./1/ProcTHOR-Test-298.scene_instance.json", + "./1/ProcTHOR-Test-417.scene_instance.json", + "./1/ProcTHOR-Test-482.scene_instance.json", + "./1/ProcTHOR-Test-864.scene_instance.json", + "./1/ProcTHOR-Test-564.scene_instance.json", + "./1/ProcTHOR-Test-352.scene_instance.json", + "./1/ProcTHOR-Test-734.scene_instance.json", + "./1/ProcTHOR-Test-48.scene_instance.json", + "./1/ProcTHOR-Test-342.scene_instance.json", + "./1/ProcTHOR-Test-388.scene_instance.json", + "./1/ProcTHOR-Test-964.scene_instance.json", + "./1/ProcTHOR-Test-603.scene_instance.json", + "./1/ProcTHOR-Test-431.scene_instance.json", + "./1/ProcTHOR-Test-224.scene_instance.json", + "./1/ProcTHOR-Test-547.scene_instance.json", + "./1/ProcTHOR-Test-936.scene_instance.json", + "./1/ProcTHOR-Test-84.scene_instance.json", + "./1/ProcTHOR-Test-350.scene_instance.json", + "./1/ProcTHOR-Test-755.scene_instance.json", + "./1/ProcTHOR-Test-11.scene_instance.json", + "./1/ProcTHOR-Test-965.scene_instance.json", + "./1/ProcTHOR-Test-751.scene_instance.json", + "./1/ProcTHOR-Test-991.scene_instance.json", + "./1/ProcTHOR-Test-30.scene_instance.json", + "./1/ProcTHOR-Test-559.scene_instance.json", + "./1/ProcTHOR-Test-275.scene_instance.json", + "./1/ProcTHOR-Test-657.scene_instance.json", + "./1/ProcTHOR-Test-776.scene_instance.json", + "./1/ProcTHOR-Test-51.scene_instance.json", + "./1/ProcTHOR-Test-649.scene_instance.json", + "./1/ProcTHOR-Test-225.scene_instance.json", + "./1/ProcTHOR-Test-35.scene_instance.json", + "./1/ProcTHOR-Test-77.scene_instance.json", + "./1/ProcTHOR-Test-737.scene_instance.json", + "./1/ProcTHOR-Test-876.scene_instance.json", + "./1/ProcTHOR-Test-145.scene_instance.json", + "./1/ProcTHOR-Test-972.scene_instance.json", + "./1/ProcTHOR-Test-566.scene_instance.json", + "./1/ProcTHOR-Test-89.scene_instance.json", + "./1/ProcTHOR-Test-368.scene_instance.json", + "./1/ProcTHOR-Test-152.scene_instance.json", + "./1/ProcTHOR-Test-116.scene_instance.json", + "./1/ProcTHOR-Test-158.scene_instance.json", + "./1/ProcTHOR-Test-976.scene_instance.json", + "./1/ProcTHOR-Test-926.scene_instance.json", + "./1/ProcTHOR-Test-795.scene_instance.json", + "./1/ProcTHOR-Test-253.scene_instance.json", + "./1/ProcTHOR-Test-759.scene_instance.json", + "./1/ProcTHOR-Test-377.scene_instance.json", + "./1/ProcTHOR-Test-983.scene_instance.json", + "./1/ProcTHOR-Test-167.scene_instance.json", + "./1/ProcTHOR-Test-277.scene_instance.json", + "./1/ProcTHOR-Test-604.scene_instance.json", + "./1/ProcTHOR-Test-196.scene_instance.json", + "./1/ProcTHOR-Test-419.scene_instance.json", + "./1/ProcTHOR-Test-523.scene_instance.json", + "./1/ProcTHOR-Test-509.scene_instance.json", + "./1/ProcTHOR-Test-383.scene_instance.json", + "./1/ProcTHOR-Test-219.scene_instance.json", + "./1/ProcTHOR-Test-18.scene_instance.json", + "./1/ProcTHOR-Test-395.scene_instance.json", + "./1/ProcTHOR-Test-658.scene_instance.json", + "./1/ProcTHOR-Test-943.scene_instance.json", + "./1/ProcTHOR-Test-542.scene_instance.json", + "./1/ProcTHOR-Test-784.scene_instance.json", + "./1/ProcTHOR-Test-595.scene_instance.json", + "./1/ProcTHOR-Test-885.scene_instance.json", + "./1/ProcTHOR-Test-806.scene_instance.json", + "./1/ProcTHOR-Test-762.scene_instance.json", + "./1/ProcTHOR-Test-382.scene_instance.json", + "./1/ProcTHOR-Test-661.scene_instance.json", + "./1/ProcTHOR-Test-842.scene_instance.json", + "./1/ProcTHOR-Test-905.scene_instance.json", + "./1/ProcTHOR-Test-385.scene_instance.json", + "./1/ProcTHOR-Test-214.scene_instance.json", + "./1/ProcTHOR-Test-944.scene_instance.json", + "./1/ProcTHOR-Test-695.scene_instance.json", + "./1/ProcTHOR-Test-351.scene_instance.json", + "./1/ProcTHOR-Test-406.scene_instance.json", + "./1/ProcTHOR-Test-41.scene_instance.json", + "./1/ProcTHOR-Test-150.scene_instance.json", + "./1/ProcTHOR-Test-540.scene_instance.json", + "./1/ProcTHOR-Test-341.scene_instance.json", + "./1/ProcTHOR-Test-384.scene_instance.json", + "./1/ProcTHOR-Test-753.scene_instance.json", + "./1/ProcTHOR-Test-237.scene_instance.json", + "./1/ProcTHOR-Test-3.scene_instance.json", + "./1/ProcTHOR-Test-689.scene_instance.json", + "./1/ProcTHOR-Test-33.scene_instance.json", + "./1/ProcTHOR-Test-668.scene_instance.json", + "./1/ProcTHOR-Test-894.scene_instance.json", + "./1/ProcTHOR-Test-987.scene_instance.json", + "./1/ProcTHOR-Test-207.scene_instance.json", + "./1/ProcTHOR-Test-280.scene_instance.json", + "./1/ProcTHOR-Test-494.scene_instance.json", + "./1/ProcTHOR-Test-502.scene_instance.json", + "./1/ProcTHOR-Test-522.scene_instance.json", + "./1/ProcTHOR-Test-774.scene_instance.json", + "./1/ProcTHOR-Test-398.scene_instance.json", + "./1/ProcTHOR-Test-532.scene_instance.json", + "./1/ProcTHOR-Test-213.scene_instance.json", + "./1/ProcTHOR-Test-135.scene_instance.json", + "./1/ProcTHOR-Test-949.scene_instance.json", + "./1/ProcTHOR-Test-236.scene_instance.json", + "./1/ProcTHOR-Test-723.scene_instance.json", + "./1/ProcTHOR-Test-551.scene_instance.json", + "./1/ProcTHOR-Test-132.scene_instance.json", + "./1/ProcTHOR-Test-901.scene_instance.json", + "./1/ProcTHOR-Test-323.scene_instance.json", + "./1/ProcTHOR-Test-715.scene_instance.json", + "./1/ProcTHOR-Test-130.scene_instance.json", + "./1/ProcTHOR-Test-772.scene_instance.json", + "./1/ProcTHOR-Test-969.scene_instance.json", + "./1/ProcTHOR-Test-853.scene_instance.json", + "./1/ProcTHOR-Test-946.scene_instance.json", + "./1/ProcTHOR-Test-71.scene_instance.json", + "./1/ProcTHOR-Test-151.scene_instance.json", + "./1/ProcTHOR-Test-673.scene_instance.json", + "./1/ProcTHOR-Test-7.scene_instance.json", + "./1/ProcTHOR-Test-707.scene_instance.json", + "./1/ProcTHOR-Test-322.scene_instance.json", + "./1/ProcTHOR-Test-840.scene_instance.json", + "./1/ProcTHOR-Test-614.scene_instance.json", + "./1/ProcTHOR-Test-247.scene_instance.json", + "./1/ProcTHOR-Test-478.scene_instance.json", + "./1/ProcTHOR-Test-127.scene_instance.json", + "./1/ProcTHOR-Test-606.scene_instance.json", + "./1/ProcTHOR-Test-496.scene_instance.json", + "./1/ProcTHOR-Test-866.scene_instance.json", + "./1/ProcTHOR-Test-557.scene_instance.json", + "./1/ProcTHOR-Test-504.scene_instance.json", + "./1/ProcTHOR-Test-317.scene_instance.json", + "./1/ProcTHOR-Test-874.scene_instance.json", + "./1/ProcTHOR-Test-249.scene_instance.json", + "./1/ProcTHOR-Test-804.scene_instance.json", + "./1/ProcTHOR-Test-528.scene_instance.json", + "./1/ProcTHOR-Test-17.scene_instance.json", + "./1/ProcTHOR-Test-688.scene_instance.json", + "./1/ProcTHOR-Test-223.scene_instance.json", + "./1/ProcTHOR-Test-508.scene_instance.json", + "./1/ProcTHOR-Test-521.scene_instance.json", + "./1/ProcTHOR-Test-215.scene_instance.json", + "./1/ProcTHOR-Test-124.scene_instance.json", + "./1/ProcTHOR-Test-186.scene_instance.json", + "./1/ProcTHOR-Test-697.scene_instance.json", + "./1/ProcTHOR-Test-307.scene_instance.json", + "./1/ProcTHOR-Test-287.scene_instance.json", + "./1/ProcTHOR-Test-402.scene_instance.json", + "./1/ProcTHOR-Test-533.scene_instance.json", + "./1/ProcTHOR-Test-373.scene_instance.json", + "./1/ProcTHOR-Test-902.scene_instance.json", + "./1/ProcTHOR-Test-257.scene_instance.json", + "./1/ProcTHOR-Test-598.scene_instance.json", + "./1/ProcTHOR-Test-498.scene_instance.json", + "./1/ProcTHOR-Test-727.scene_instance.json", + "./1/ProcTHOR-Test-49.scene_instance.json", + "./1/ProcTHOR-Test-113.scene_instance.json", + "./1/ProcTHOR-Test-685.scene_instance.json", + "./1/ProcTHOR-Test-813.scene_instance.json", + "./1/ProcTHOR-Test-627.scene_instance.json", + "./1/ProcTHOR-Test-466.scene_instance.json", + "./1/ProcTHOR-Test-948.scene_instance.json", + "./1/ProcTHOR-Test-422.scene_instance.json", + "./1/ProcTHOR-Test-970.scene_instance.json", + "./1/ProcTHOR-Test-659.scene_instance.json", + "./1/ProcTHOR-Test-891.scene_instance.json", + "./1/ProcTHOR-Test-12.scene_instance.json", + "./1/ProcTHOR-Test-660.scene_instance.json", + "./1/ProcTHOR-Test-470.scene_instance.json", + "./1/ProcTHOR-Test-645.scene_instance.json", + "./1/ProcTHOR-Test-367.scene_instance.json", + "./1/ProcTHOR-Test-827.scene_instance.json", + "./1/ProcTHOR-Test-468.scene_instance.json", + "./1/ProcTHOR-Test-501.scene_instance.json", + "./1/ProcTHOR-Test-790.scene_instance.json", + "./1/ProcTHOR-Test-585.scene_instance.json", + "./1/ProcTHOR-Test-857.scene_instance.json", + "./1/ProcTHOR-Test-814.scene_instance.json", + "./1/ProcTHOR-Test-875.scene_instance.json", + "./1/ProcTHOR-Test-220.scene_instance.json", + "./1/ProcTHOR-Test-413.scene_instance.json", + "./1/ProcTHOR-Test-781.scene_instance.json", + "./1/ProcTHOR-Test-336.scene_instance.json", + "./1/ProcTHOR-Test-106.scene_instance.json", + "./1/ProcTHOR-Test-338.scene_instance.json", + "./1/ProcTHOR-Test-469.scene_instance.json", + "./1/ProcTHOR-Test-899.scene_instance.json", + "./1/ProcTHOR-Test-710.scene_instance.json", + "./1/ProcTHOR-Test-766.scene_instance.json", + "./1/ProcTHOR-Test-102.scene_instance.json", + "./1/ProcTHOR-Test-67.scene_instance.json", + "./1/ProcTHOR-Test-191.scene_instance.json", + "./1/ProcTHOR-Test-971.scene_instance.json", + "./1/ProcTHOR-Test-918.scene_instance.json", + "./1/ProcTHOR-Test-537.scene_instance.json", + "./1/ProcTHOR-Test-628.scene_instance.json", + "./1/ProcTHOR-Test-855.scene_instance.json", + "./1/ProcTHOR-Test-42.scene_instance.json", + "./1/ProcTHOR-Test-260.scene_instance.json", + "./1/ProcTHOR-Test-356.scene_instance.json", + "./1/ProcTHOR-Test-583.scene_instance.json", + "./1/ProcTHOR-Test-64.scene_instance.json", + "./1/ProcTHOR-Test-663.scene_instance.json", + "./1/ProcTHOR-Test-886.scene_instance.json", + "./1/ProcTHOR-Test-913.scene_instance.json", + "./1/ProcTHOR-Test-911.scene_instance.json", + "./1/ProcTHOR-Test-953.scene_instance.json", + "./1/ProcTHOR-Test-691.scene_instance.json", + "./1/ProcTHOR-Test-347.scene_instance.json", + "./1/ProcTHOR-Test-990.scene_instance.json", + "./1/ProcTHOR-Test-221.scene_instance.json", + "./1/ProcTHOR-Test-348.scene_instance.json", + "./1/ProcTHOR-Test-915.scene_instance.json", + "./1/ProcTHOR-Test-119.scene_instance.json", + "./1/ProcTHOR-Test-893.scene_instance.json", + "./1/ProcTHOR-Test-613.scene_instance.json", + "./1/ProcTHOR-Test-757.scene_instance.json", + "./1/ProcTHOR-Test-185.scene_instance.json", + "./1/ProcTHOR-Test-266.scene_instance.json", + "./1/ProcTHOR-Test-779.scene_instance.json", + "./1/ProcTHOR-Test-300.scene_instance.json", + "./1/ProcTHOR-Test-770.scene_instance.json", + "./1/ProcTHOR-Test-883.scene_instance.json", + "./1/ProcTHOR-Test-95.scene_instance.json", + "./1/ProcTHOR-Test-425.scene_instance.json", + "./1/ProcTHOR-Test-31.scene_instance.json", + "./1/ProcTHOR-Test-728.scene_instance.json", + "./1/ProcTHOR-Test-978.scene_instance.json", + "./1/ProcTHOR-Test-635.scene_instance.json", + "./1/ProcTHOR-Test-550.scene_instance.json", + "./1/ProcTHOR-Test-746.scene_instance.json", + "./1/ProcTHOR-Test-530.scene_instance.json", + "./1/ProcTHOR-Test-315.scene_instance.json", + "./1/ProcTHOR-Test-631.scene_instance.json", + "./1/ProcTHOR-Test-101.scene_instance.json", + "./1/ProcTHOR-Test-714.scene_instance.json", + "./1/ProcTHOR-Test-722.scene_instance.json", + "./1/ProcTHOR-Test-474.scene_instance.json", + "./1/ProcTHOR-Test-756.scene_instance.json", + "./1/ProcTHOR-Test-32.scene_instance.json", + "./1/ProcTHOR-Test-730.scene_instance.json", + "./1/ProcTHOR-Test-675.scene_instance.json", + "./1/ProcTHOR-Test-597.scene_instance.json", + "./1/ProcTHOR-Test-98.scene_instance.json", + "./1/ProcTHOR-Test-815.scene_instance.json", + "./1/ProcTHOR-Test-963.scene_instance.json", + "./1/ProcTHOR-Test-63.scene_instance.json", + "./1/ProcTHOR-Test-143.scene_instance.json", + "./1/ProcTHOR-Test-58.scene_instance.json", + "./1/ProcTHOR-Test-453.scene_instance.json", + "./1/ProcTHOR-Test-548.scene_instance.json", + "./1/ProcTHOR-Test-325.scene_instance.json", + "./1/ProcTHOR-Test-93.scene_instance.json", + "./1/ProcTHOR-Test-2.scene_instance.json", + "./1/ProcTHOR-Test-203.scene_instance.json", + "./1/ProcTHOR-Test-838.scene_instance.json", + "./1/ProcTHOR-Test-858.scene_instance.json", + "./1/ProcTHOR-Test-863.scene_instance.json", + "./1/ProcTHOR-Test-951.scene_instance.json", + "./1/ProcTHOR-Test-702.scene_instance.json", + "./1/ProcTHOR-Test-611.scene_instance.json", + "./1/ProcTHOR-Test-906.scene_instance.json", + "./1/ProcTHOR-Test-139.scene_instance.json", + "./1/ProcTHOR-Test-226.scene_instance.json", + "./1/ProcTHOR-Test-271.scene_instance.json", + "./1/ProcTHOR-Test-82.scene_instance.json", + "./1/ProcTHOR-Test-176.scene_instance.json", + "./1/ProcTHOR-Test-693.scene_instance.json", + "./1/ProcTHOR-Test-785.scene_instance.json", + "./1/ProcTHOR-Test-503.scene_instance.json", + "./1/ProcTHOR-Test-808.scene_instance.json", + "./1/ProcTHOR-Test-9.scene_instance.json", + "./1/ProcTHOR-Test-397.scene_instance.json", + "./1/ProcTHOR-Test-451.scene_instance.json", + "./1/ProcTHOR-Test-279.scene_instance.json", + "./1/ProcTHOR-Test-676.scene_instance.json", + "./1/ProcTHOR-Test-244.scene_instance.json", + "./1/ProcTHOR-Test-125.scene_instance.json", + "./1/ProcTHOR-Test-942.scene_instance.json", + "./1/ProcTHOR-Test-163.scene_instance.json", + "./1/ProcTHOR-Test-824.scene_instance.json", + "./1/ProcTHOR-Test-239.scene_instance.json", + "./1/ProcTHOR-Test-285.scene_instance.json", + "./1/ProcTHOR-Test-230.scene_instance.json", + "./1/ProcTHOR-Test-490.scene_instance.json", + "./1/ProcTHOR-Test-79.scene_instance.json", + "./1/ProcTHOR-Test-850.scene_instance.json", + "./1/ProcTHOR-Test-981.scene_instance.json", + "./1/ProcTHOR-Test-799.scene_instance.json", + "./1/ProcTHOR-Test-594.scene_instance.json", + "./1/ProcTHOR-Test-303.scene_instance.json", + "./1/ProcTHOR-Test-202.scene_instance.json", + "./1/ProcTHOR-Test-904.scene_instance.json", + "./1/ProcTHOR-Test-823.scene_instance.json", + "./1/ProcTHOR-Test-961.scene_instance.json", + "./1/ProcTHOR-Test-337.scene_instance.json", + "./1/ProcTHOR-Test-543.scene_instance.json", + "./1/ProcTHOR-Test-444.scene_instance.json", + "./1/ProcTHOR-Test-455.scene_instance.json", + "./1/ProcTHOR-Test-506.scene_instance.json", + "./1/ProcTHOR-Test-165.scene_instance.json", + "./1/ProcTHOR-Test-869.scene_instance.json", + "./1/ProcTHOR-Test-927.scene_instance.json", + "./1/ProcTHOR-Test-133.scene_instance.json", + "./1/ProcTHOR-Test-404.scene_instance.json", + "./1/ProcTHOR-Test-204.scene_instance.json", + "./1/ProcTHOR-Test-541.scene_instance.json", + "./1/ProcTHOR-Test-554.scene_instance.json", + "./1/ProcTHOR-Test-745.scene_instance.json", + "./1/ProcTHOR-Test-136.scene_instance.json", + "./1/ProcTHOR-Test-381.scene_instance.json", + "./1/ProcTHOR-Test-201.scene_instance.json", + "./1/ProcTHOR-Test-472.scene_instance.json", + "./1/ProcTHOR-Test-205.scene_instance.json", + "./1/ProcTHOR-Test-791.scene_instance.json", + "./1/ProcTHOR-Test-870.scene_instance.json", + "./1/ProcTHOR-Test-844.scene_instance.json", + "./1/ProcTHOR-Test-575.scene_instance.json", + "./1/ProcTHOR-Test-620.scene_instance.json", + "./1/ProcTHOR-Test-739.scene_instance.json", + "./1/ProcTHOR-Test-578.scene_instance.json", + "./1/ProcTHOR-Test-980.scene_instance.json", + "./1/ProcTHOR-Test-939.scene_instance.json", + "./1/ProcTHOR-Test-54.scene_instance.json", + "./1/ProcTHOR-Test-967.scene_instance.json", + "./1/ProcTHOR-Test-958.scene_instance.json", + "./1/ProcTHOR-Test-263.scene_instance.json", + "./1/ProcTHOR-Test-258.scene_instance.json", + "./1/ProcTHOR-Test-440.scene_instance.json", + "./1/ProcTHOR-Test-261.scene_instance.json", + "./1/ProcTHOR-Test-941.scene_instance.json", + "./1/ProcTHOR-Test-255.scene_instance.json", + "./1/ProcTHOR-Test-754.scene_instance.json", + "./1/ProcTHOR-Test-513.scene_instance.json", + "./1/ProcTHOR-Test-297.scene_instance.json", + "./1/ProcTHOR-Test-394.scene_instance.json", + "./1/ProcTHOR-Test-769.scene_instance.json", + "./1/ProcTHOR-Test-609.scene_instance.json", + "./1/ProcTHOR-Test-589.scene_instance.json", + "./1/ProcTHOR-Test-232.scene_instance.json", + "./1/ProcTHOR-Test-703.scene_instance.json", + "./1/ProcTHOR-Test-535.scene_instance.json", + "./1/ProcTHOR-Test-138.scene_instance.json", + "./1/ProcTHOR-Test-62.scene_instance.json", + "./1/ProcTHOR-Test-427.scene_instance.json", + "./1/ProcTHOR-Test-10.scene_instance.json", + "./1/ProcTHOR-Test-573.scene_instance.json", + "./1/ProcTHOR-Test-903.scene_instance.json", + "./1/ProcTHOR-Test-238.scene_instance.json", + "./1/ProcTHOR-Test-128.scene_instance.json", + "./1/ProcTHOR-Test-590.scene_instance.json", + "./1/ProcTHOR-Test-882.scene_instance.json", + "./1/ProcTHOR-Test-642.scene_instance.json", + "./1/ProcTHOR-Test-705.scene_instance.json", + "./1/ProcTHOR-Test-210.scene_instance.json", + "./1/ProcTHOR-Test-512.scene_instance.json", + "./1/ProcTHOR-Test-636.scene_instance.json", + "./1/ProcTHOR-Test-852.scene_instance.json", + "./1/ProcTHOR-Test-90.scene_instance.json", + "./1/ProcTHOR-Test-748.scene_instance.json", + "./1/ProcTHOR-Test-829.scene_instance.json", + "./1/ProcTHOR-Test-860.scene_instance.json", + "./1/ProcTHOR-Test-454.scene_instance.json", + "./1/ProcTHOR-Test-665.scene_instance.json", + "./1/ProcTHOR-Test-529.scene_instance.json", + "./1/ProcTHOR-Test-365.scene_instance.json", + "./1/ProcTHOR-Test-20.scene_instance.json", + "./1/ProcTHOR-Test-485.scene_instance.json", + "./1/ProcTHOR-Test-291.scene_instance.json", + "./1/ProcTHOR-Test-448.scene_instance.json", + "./1/ProcTHOR-Test-209.scene_instance.json", + "./1/ProcTHOR-Test-480.scene_instance.json", + "./1/ProcTHOR-Test-276.scene_instance.json", + "./1/ProcTHOR-Test-195.scene_instance.json", + "./1/ProcTHOR-Test-254.scene_instance.json", + "./1/ProcTHOR-Test-531.scene_instance.json", + "./1/ProcTHOR-Test-518.scene_instance.json", + "./1/ProcTHOR-Test-94.scene_instance.json", + "./1/ProcTHOR-Test-66.scene_instance.json", + "./1/ProcTHOR-Test-174.scene_instance.json", + "./1/ProcTHOR-Test-81.scene_instance.json", + "./1/ProcTHOR-Test-25.scene_instance.json", + "./1/ProcTHOR-Test-187.scene_instance.json", + "./1/ProcTHOR-Test-989.scene_instance.json", + "./1/ProcTHOR-Test-732.scene_instance.json", + "./1/ProcTHOR-Test-556.scene_instance.json", + "./1/ProcTHOR-Test-797.scene_instance.json", + "./1/ProcTHOR-Test-55.scene_instance.json", + "./1/ProcTHOR-Test-149.scene_instance.json", + "./1/ProcTHOR-Test-741.scene_instance.json", + "./1/ProcTHOR-Test-565.scene_instance.json", + "./1/ProcTHOR-Test-677.scene_instance.json", + "./1/ProcTHOR-Test-14.scene_instance.json", + "./1/ProcTHOR-Test-471.scene_instance.json", + "./1/ProcTHOR-Test-900.scene_instance.json", + "./1/ProcTHOR-Test-975.scene_instance.json", + "./1/ProcTHOR-Test-412.scene_instance.json", + "./1/ProcTHOR-Test-246.scene_instance.json", + "./1/ProcTHOR-Test-536.scene_instance.json", + "./1/ProcTHOR-Test-486.scene_instance.json", + "./1/ProcTHOR-Test-189.scene_instance.json", + "./1/ProcTHOR-Test-851.scene_instance.json", + "./1/ProcTHOR-Test-333.scene_instance.json", + "./1/ProcTHOR-Test-8.scene_instance.json", + "./1/ProcTHOR-Test-622.scene_instance.json", + "./1/ProcTHOR-Test-849.scene_instance.json", + "./1/ProcTHOR-Test-783.scene_instance.json", + "./1/ProcTHOR-Test-966.scene_instance.json", + "./1/ProcTHOR-Test-837.scene_instance.json", + "./1/ProcTHOR-Test-190.scene_instance.json", + "./1/ProcTHOR-Test-28.scene_instance.json", + "./1/ProcTHOR-Test-889.scene_instance.json", + "./1/ProcTHOR-Test-353.scene_instance.json", + "./1/ProcTHOR-Test-925.scene_instance.json", + "./1/ProcTHOR-Test-235.scene_instance.json", + "./1/ProcTHOR-Test-686.scene_instance.json", + "./1/ProcTHOR-Test-672.scene_instance.json", + "./1/ProcTHOR-Test-777.scene_instance.json", + "./1/ProcTHOR-Test-437.scene_instance.json", + "./1/ProcTHOR-Test-375.scene_instance.json", + "./1/ProcTHOR-Test-107.scene_instance.json", + "./1/ProcTHOR-Test-892.scene_instance.json", + "./1/ProcTHOR-Test-481.scene_instance.json", + "./1/ProcTHOR-Test-371.scene_instance.json", + "./1/ProcTHOR-Test-433.scene_instance.json", + "./1/ProcTHOR-Test-405.scene_instance.json", + "./1/ProcTHOR-Test-296.scene_instance.json", + "./1/ProcTHOR-Test-647.scene_instance.json", + "./1/ProcTHOR-Test-719.scene_instance.json", + "./1/ProcTHOR-Test-465.scene_instance.json", + "./1/ProcTHOR-Test-168.scene_instance.json", + "./1/ProcTHOR-Test-803.scene_instance.json", + "./1/ProcTHOR-Test-881.scene_instance.json", + "./1/ProcTHOR-Test-430.scene_instance.json", + "./1/ProcTHOR-Test-311.scene_instance.json", + "./1/ProcTHOR-Test-593.scene_instance.json", + "./1/ProcTHOR-Test-681.scene_instance.json", + "./1/ProcTHOR-Test-326.scene_instance.json", + "./1/ProcTHOR-Test-579.scene_instance.json", + "./1/ProcTHOR-Test-848.scene_instance.json", + "./1/ProcTHOR-Test-122.scene_instance.json", + "./1/ProcTHOR-Test-269.scene_instance.json", + "./1/ProcTHOR-Test-546.scene_instance.json", + "./1/ProcTHOR-Test-922.scene_instance.json", + "./1/ProcTHOR-Test-146.scene_instance.json", + "./1/ProcTHOR-Test-389.scene_instance.json", + "./1/ProcTHOR-Test-475.scene_instance.json", + "./1/ProcTHOR-Test-160.scene_instance.json", + "./1/ProcTHOR-Test-37.scene_instance.json", + "./1/ProcTHOR-Test-920.scene_instance.json", + "./1/ProcTHOR-Test-462.scene_instance.json", + "./1/ProcTHOR-Test-290.scene_instance.json", + "./1/ProcTHOR-Test-545.scene_instance.json", + "./1/ProcTHOR-Test-177.scene_instance.json", + "./1/ProcTHOR-Test-641.scene_instance.json", + "./1/ProcTHOR-Test-22.scene_instance.json", + "./1/ProcTHOR-Test-861.scene_instance.json", + "./1/ProcTHOR-Test-742.scene_instance.json", + "./1/ProcTHOR-Test-959.scene_instance.json", + "./1/ProcTHOR-Test-396.scene_instance.json", + "./1/ProcTHOR-Test-956.scene_instance.json", + "./1/ProcTHOR-Test-301.scene_instance.json", + "./1/ProcTHOR-Test-765.scene_instance.json", + "./1/ProcTHOR-Test-198.scene_instance.json", + "./1/ProcTHOR-Test-330.scene_instance.json", + "./1/ProcTHOR-Test-787.scene_instance.json", + "./1/ProcTHOR-Test-524.scene_instance.json", + "./1/ProcTHOR-Test-324.scene_instance.json", + "./1/ProcTHOR-Test-683.scene_instance.json", + "./1/ProcTHOR-Test-61.scene_instance.json", + "./1/ProcTHOR-Test-743.scene_instance.json", + "./1/ProcTHOR-Test-526.scene_instance.json", + "./1/ProcTHOR-Test-69.scene_instance.json", + "./1/ProcTHOR-Test-780.scene_instance.json", + "./1/ProcTHOR-Test-380.scene_instance.json", + "./1/ProcTHOR-Test-867.scene_instance.json", + "./1/ProcTHOR-Test-148.scene_instance.json", + "./1/ProcTHOR-Test-75.scene_instance.json", + "./1/ProcTHOR-Test-362.scene_instance.json", + "./1/ProcTHOR-Test-227.scene_instance.json", + "./1/ProcTHOR-Test-305.scene_instance.json", + "./1/ProcTHOR-Test-346.scene_instance.json", + "./1/ProcTHOR-Test-826.scene_instance.json", + "./1/ProcTHOR-Test-252.scene_instance.json", + "./1/ProcTHOR-Test-142.scene_instance.json", + "./1/ProcTHOR-Test-800.scene_instance.json", + "./1/ProcTHOR-Test-109.scene_instance.json", + "./1/ProcTHOR-Test-15.scene_instance.json", + "./1/ProcTHOR-Test-194.scene_instance.json", + "./1/ProcTHOR-Test-39.scene_instance.json", + "./1/ProcTHOR-Test-173.scene_instance.json", + "./1/ProcTHOR-Test-859.scene_instance.json", + "./1/ProcTHOR-Test-793.scene_instance.json", + "./1/ProcTHOR-Test-50.scene_instance.json", + "./1/ProcTHOR-Test-985.scene_instance.json", + "./1/ProcTHOR-Test-973.scene_instance.json", + "./1/ProcTHOR-Test-420.scene_instance.json", + "./1/ProcTHOR-Test-234.scene_instance.json", + "./1/ProcTHOR-Test-278.scene_instance.json", + "./1/ProcTHOR-Test-930.scene_instance.json", + "./1/ProcTHOR-Test-586.scene_instance.json", + "./1/ProcTHOR-Test-822.scene_instance.json", + "./1/ProcTHOR-Test-520.scene_instance.json", + "./1/ProcTHOR-Test-391.scene_instance.json", + "./1/ProcTHOR-Test-580.scene_instance.json", + "./1/ProcTHOR-Test-999.scene_instance.json", + "./1/ProcTHOR-Test-299.scene_instance.json", + "./1/ProcTHOR-Test-789.scene_instance.json", + "./1/ProcTHOR-Test-656.scene_instance.json", + "./1/ProcTHOR-Test-308.scene_instance.json", + "./1/ProcTHOR-Test-403.scene_instance.json", + "./1/ProcTHOR-Test-111.scene_instance.json", + "./1/ProcTHOR-Test-617.scene_instance.json", + "./1/ProcTHOR-Test-616.scene_instance.json", + "./1/ProcTHOR-Test-171.scene_instance.json", + "./1/ProcTHOR-Test-805.scene_instance.json", + "./1/ProcTHOR-Test-5.scene_instance.json", + "./1/ProcTHOR-Test-801.scene_instance.json", + "./1/ProcTHOR-Test-831.scene_instance.json", + "./1/ProcTHOR-Test-773.scene_instance.json", + "./1/ProcTHOR-Test-929.scene_instance.json", + "./1/ProcTHOR-Test-463.scene_instance.json", + "./1/ProcTHOR-Test-816.scene_instance.json", + "./1/ProcTHOR-Test-699.scene_instance.json", + "./1/ProcTHOR-Test-166.scene_instance.json", + "./1/ProcTHOR-Test-445.scene_instance.json", + "./1/ProcTHOR-Test-740.scene_instance.json", + "./1/ProcTHOR-Test-13.scene_instance.json", + "./1/ProcTHOR-Test-144.scene_instance.json", + "./1/ProcTHOR-Test-706.scene_instance.json", + "./1/ProcTHOR-Test-228.scene_instance.json", + "./1/ProcTHOR-Test-839.scene_instance.json", + "./1/ProcTHOR-Test-156.scene_instance.json", + "./1/ProcTHOR-Test-640.scene_instance.json", + "./1/ProcTHOR-Test-295.scene_instance.json", + "./1/ProcTHOR-Test-361.scene_instance.json", + "./1/ProcTHOR-Test-935.scene_instance.json", + "./1/ProcTHOR-Test-605.scene_instance.json", + "./1/ProcTHOR-Test-110.scene_instance.json", + "./1/ProcTHOR-Test-692.scene_instance.json", + "./1/ProcTHOR-Test-335.scene_instance.json", + "./1/ProcTHOR-Test-212.scene_instance.json", + "./1/ProcTHOR-Test-96.scene_instance.json", + "./1/ProcTHOR-Test-682.scene_instance.json", + "./1/ProcTHOR-Test-87.scene_instance.json", + "./1/ProcTHOR-Test-763.scene_instance.json", + "./1/ProcTHOR-Test-895.scene_instance.json", + "./1/ProcTHOR-Test-792.scene_instance.json", + "./1/ProcTHOR-Test-761.scene_instance.json", + "./1/ProcTHOR-Test-596.scene_instance.json", + "./1/ProcTHOR-Test-825.scene_instance.json", + "./1/ProcTHOR-Test-884.scene_instance.json", + "./1/ProcTHOR-Test-408.scene_instance.json", + "./1/ProcTHOR-Test-91.scene_instance.json", + "./1/ProcTHOR-Test-131.scene_instance.json", + "./1/ProcTHOR-Test-538.scene_instance.json", + "./1/ProcTHOR-Test-70.scene_instance.json", + "./1/ProcTHOR-Test-674.scene_instance.json", + "./1/ProcTHOR-Test-331.scene_instance.json", + "./1/ProcTHOR-Test-114.scene_instance.json", + "./1/ProcTHOR-Test-809.scene_instance.json", + "./1/ProcTHOR-Test-558.scene_instance.json", + "./1/ProcTHOR-Test-339.scene_instance.json", + "./1/ProcTHOR-Test-919.scene_instance.json", + "./1/ProcTHOR-Test-601.scene_instance.json", + "./1/ProcTHOR-Test-319.scene_instance.json", + "./1/ProcTHOR-Test-553.scene_instance.json", + "./1/ProcTHOR-Test-652.scene_instance.json", + "./1/ProcTHOR-Test-309.scene_instance.json", + "./1/ProcTHOR-Test-364.scene_instance.json", + "./1/ProcTHOR-Test-771.scene_instance.json", + "./1/ProcTHOR-Test-118.scene_instance.json", + "./1/ProcTHOR-Test-435.scene_instance.json", + "./1/ProcTHOR-Test-574.scene_instance.json", + "./1/ProcTHOR-Test-46.scene_instance.json", + "./1/ProcTHOR-Test-880.scene_instance.json", + "./1/ProcTHOR-Test-154.scene_instance.json", + "./1/ProcTHOR-Test-679.scene_instance.json", + "./1/ProcTHOR-Test-137.scene_instance.json", + "./1/ProcTHOR-Test-897.scene_instance.json", + "./1/ProcTHOR-Test-442.scene_instance.json", + "./1/ProcTHOR-Test-760.scene_instance.json", + "./1/ProcTHOR-Test-483.scene_instance.json", + "./1/ProcTHOR-Test-873.scene_instance.json", + "./1/ProcTHOR-Test-340.scene_instance.json", + "./1/ProcTHOR-Test-23.scene_instance.json", + "./1/ProcTHOR-Test-120.scene_instance.json", + "./1/ProcTHOR-Test-229.scene_instance.json", + "./1/ProcTHOR-Test-44.scene_instance.json", + "./1/ProcTHOR-Test-957.scene_instance.json", + "./1/ProcTHOR-Test-206.scene_instance.json", + "./1/ProcTHOR-Test-854.scene_instance.json", + "./1/ProcTHOR-Test-376.scene_instance.json", + "./1/ProcTHOR-Test-57.scene_instance.json", + "./1/ProcTHOR-Test-644.scene_instance.json", + "./1/ProcTHOR-Test-729.scene_instance.json", + "./1/ProcTHOR-Test-877.scene_instance.json", + "./1/ProcTHOR-Test-183.scene_instance.json", + "./1/ProcTHOR-Test-250.scene_instance.json", + "./1/ProcTHOR-Test-73.scene_instance.json", + "./1/ProcTHOR-Test-218.scene_instance.json", + "./1/ProcTHOR-Test-140.scene_instance.json", + "./1/ProcTHOR-Test-671.scene_instance.json", + "./1/ProcTHOR-Test-567.scene_instance.json", + "./1/ProcTHOR-Test-615.scene_instance.json", + "./1/ProcTHOR-Test-56.scene_instance.json", + "./1/ProcTHOR-Test-568.scene_instance.json", + "./1/ProcTHOR-Test-576.scene_instance.json", + "./1/ProcTHOR-Test-401.scene_instance.json", + "./1/ProcTHOR-Test-243.scene_instance.json", + "./1/ProcTHOR-Test-798.scene_instance.json", + "./1/ProcTHOR-Test-924.scene_instance.json", + "./1/ProcTHOR-Test-241.scene_instance.json", + "./1/ProcTHOR-Test-984.scene_instance.json", + "./1/ProcTHOR-Test-912.scene_instance.json", + "./1/ProcTHOR-Test-286.scene_instance.json", + "./1/ProcTHOR-Test-712.scene_instance.json", + "./1/ProcTHOR-Test-349.scene_instance.json", + "./1/ProcTHOR-Test-986.scene_instance.json", + "./1/ProcTHOR-Test-92.scene_instance.json", + "./1/ProcTHOR-Test-449.scene_instance.json", + "./1/ProcTHOR-Test-493.scene_instance.json", + "./1/ProcTHOR-Test-262.scene_instance.json", + "./1/ProcTHOR-Test-599.scene_instance.json", + "./1/ProcTHOR-Test-162.scene_instance.json", + "./1/ProcTHOR-Test-441.scene_instance.json", + "./1/ProcTHOR-Test-639.scene_instance.json", + "./1/ProcTHOR-Test-294.scene_instance.json", + "./1/ProcTHOR-Test-782.scene_instance.json", + "./1/ProcTHOR-Test-767.scene_instance.json", + "./1/ProcTHOR-Test-898.scene_instance.json", + "./1/ProcTHOR-Test-938.scene_instance.json", + "./1/ProcTHOR-Test-188.scene_instance.json", + "./1/ProcTHOR-Test-428.scene_instance.json", + "./1/ProcTHOR-Test-72.scene_instance.json", + "./1/ProcTHOR-Test-123.scene_instance.json", + "./1/ProcTHOR-Test-704.scene_instance.json", + "./1/ProcTHOR-Test-846.scene_instance.json", + "./1/ProcTHOR-Test-487.scene_instance.json", + "./1/ProcTHOR-Test-438.scene_instance.json", + "./1/ProcTHOR-Test-713.scene_instance.json", + "./1/ProcTHOR-Test-630.scene_instance.json", + "./1/ProcTHOR-Test-164.scene_instance.json", + "./1/ProcTHOR-Test-525.scene_instance.json", + "./1/ProcTHOR-Test-59.scene_instance.json", + "./1/ProcTHOR-Test-646.scene_instance.json", + "./1/ProcTHOR-Test-634.scene_instance.json", + "./1/ProcTHOR-Test-312.scene_instance.json", + "./1/ProcTHOR-Test-155.scene_instance.json", + "./1/ProcTHOR-Test-872.scene_instance.json", + "./1/ProcTHOR-Test-36.scene_instance.json", + "./1/ProcTHOR-Test-819.scene_instance.json", + "./1/ProcTHOR-Test-835.scene_instance.json", + "./1/ProcTHOR-Test-434.scene_instance.json", + "./1/ProcTHOR-Test-281.scene_instance.json", + "./1/ProcTHOR-Test-117.scene_instance.json", + "./1/ProcTHOR-Test-161.scene_instance.json", + "./1/ProcTHOR-Test-818.scene_instance.json", + "./1/ProcTHOR-Test-650.scene_instance.json", + "./1/ProcTHOR-Test-484.scene_instance.json", + "./1/ProcTHOR-Test-47.scene_instance.json", + "./1/ProcTHOR-Test-992.scene_instance.json", + "./1/ProcTHOR-Test-638.scene_instance.json", + "./1/ProcTHOR-Test-648.scene_instance.json", + "./1/ProcTHOR-Test-914.scene_instance.json", + "./1/ProcTHOR-Test-53.scene_instance.json", + "./1/ProcTHOR-Test-423.scene_instance.json", + "./1/ProcTHOR-Test-74.scene_instance.json", + "./1/ProcTHOR-Test-233.scene_instance.json", + "./1/ProcTHOR-Test-27.scene_instance.json", + "./1/ProcTHOR-Test-868.scene_instance.json", + "./1/ProcTHOR-Test-157.scene_instance.json", + "./1/ProcTHOR-Test-370.scene_instance.json", + "./1/ProcTHOR-Test-600.scene_instance.json", + "./1/ProcTHOR-Test-588.scene_instance.json", + "./1/ProcTHOR-Test-97.scene_instance.json", + "./1/ProcTHOR-Test-456.scene_instance.json", + "./1/ProcTHOR-Test-747.scene_instance.json", + "./1/ProcTHOR-Test-147.scene_instance.json", + "./1/ProcTHOR-Test-735.scene_instance.json", + "./1/ProcTHOR-Test-724.scene_instance.json", + "./1/ProcTHOR-Test-862.scene_instance.json", + "./1/ProcTHOR-Test-701.scene_instance.json", + "./1/ProcTHOR-Test-563.scene_instance.json", + "./1/ProcTHOR-Test-29.scene_instance.json", + "./1/ProcTHOR-Test-268.scene_instance.json", + "./1/ProcTHOR-Test-527.scene_instance.json", + "./1/ProcTHOR-Test-871.scene_instance.json", + "./1/ProcTHOR-Test-954.scene_instance.json", + "./1/ProcTHOR-Test-34.scene_instance.json", + "./1/ProcTHOR-Test-549.scene_instance.json", + "./1/ProcTHOR-Test-555.scene_instance.json", + "./1/ProcTHOR-Test-270.scene_instance.json", + "./1/ProcTHOR-Test-516.scene_instance.json", + "./1/ProcTHOR-Test-997.scene_instance.json", + "./1/ProcTHOR-Test-794.scene_instance.json", + "./1/ProcTHOR-Test-950.scene_instance.json", + "./1/ProcTHOR-Test-179.scene_instance.json", + "./1/ProcTHOR-Test-633.scene_instance.json", + "./1/ProcTHOR-Test-979.scene_instance.json", + "./1/ProcTHOR-Test-796.scene_instance.json", + "./1/ProcTHOR-Test-993.scene_instance.json", + "./1/ProcTHOR-Test-725.scene_instance.json", + "./1/ProcTHOR-Test-561.scene_instance.json", + "./1/ProcTHOR-Test-608.scene_instance.json", + "./1/ProcTHOR-Test-211.scene_instance.json", + "./1/ProcTHOR-Test-344.scene_instance.json", + "./1/ProcTHOR-Test-664.scene_instance.json", + "./1/ProcTHOR-Test-717.scene_instance.json", + "./1/ProcTHOR-Test-76.scene_instance.json", + "./1/ProcTHOR-Test-960.scene_instance.json", + "./1/ProcTHOR-Test-447.scene_instance.json", + "./1/ProcTHOR-Test-662.scene_instance.json", + "./1/ProcTHOR-Test-977.scene_instance.json", + "./1/ProcTHOR-Test-619.scene_instance.json", + "./1/ProcTHOR-Test-321.scene_instance.json", + "./1/ProcTHOR-Test-909.scene_instance.json", + "./1/ProcTHOR-Test-88.scene_instance.json", + "./1/ProcTHOR-Test-587.scene_instance.json", + "./1/ProcTHOR-Test-921.scene_instance.json", + "./1/ProcTHOR-Test-400.scene_instance.json", + "./1/ProcTHOR-Test-68.scene_instance.json", + "./1/ProcTHOR-Test-418.scene_instance.json", + "./1/ProcTHOR-Test-460.scene_instance.json", + "./1/ProcTHOR-Test-629.scene_instance.json", + "./1/ProcTHOR-Test-678.scene_instance.json", + "./1/ProcTHOR-Test-923.scene_instance.json", + "./1/ProcTHOR-Test-288.scene_instance.json", + "./1/ProcTHOR-Test-940.scene_instance.json", + "./1/ProcTHOR-Test-592.scene_instance.json", + "./1/ProcTHOR-Test-996.scene_instance.json", + "./1/ProcTHOR-Test-908.scene_instance.json", + "./1/ProcTHOR-Test-750.scene_instance.json", + "./1/ProcTHOR-Test-424.scene_instance.json", + "./1/ProcTHOR-Test-464.scene_instance.json", + "./1/ProcTHOR-Test-310.scene_instance.json", + "./1/ProcTHOR-Test-744.scene_instance.json", + "./1/ProcTHOR-Test-982.scene_instance.json", + "./1/ProcTHOR-Test-306.scene_instance.json", + "./1/ProcTHOR-Test-888.scene_instance.json", + "./1/ProcTHOR-Test-273.scene_instance.json", + "./1/ProcTHOR-Test-890.scene_instance.json", + "./1/ProcTHOR-Test-358.scene_instance.json", + "./1/ProcTHOR-Test-945.scene_instance.json", + "./1/ProcTHOR-Test-172.scene_instance.json", + "./1/ProcTHOR-Test-544.scene_instance.json", + "./1/ProcTHOR-Test-514.scene_instance.json", + "./1/ProcTHOR-Test-510.scene_instance.json", + "./1/ProcTHOR-Test-259.scene_instance.json", + "./1/ProcTHOR-Test-988.scene_instance.json", + "./1/ProcTHOR-Test-459.scene_instance.json", + "./1/ProcTHOR-Test-178.scene_instance.json", + "./1/ProcTHOR-Test-752.scene_instance.json", + "./1/ProcTHOR-Test-314.scene_instance.json", + "./1/ProcTHOR-Test-182.scene_instance.json", + "./1/ProcTHOR-Test-217.scene_instance.json", + "./1/ProcTHOR-Test-758.scene_instance.json", + "./1/ProcTHOR-Test-245.scene_instance.json", + "./1/ProcTHOR-Test-749.scene_instance.json", + "./1/ProcTHOR-Test-452.scene_instance.json", + "./1/ProcTHOR-Test-698.scene_instance.json", + "./1/ProcTHOR-Test-103.scene_instance.json", + "./1/ProcTHOR-Test-841.scene_instance.json", + "./1/ProcTHOR-Test-6.scene_instance.json", + "./1/ProcTHOR-Test-670.scene_instance.json", + "./1/ProcTHOR-Test-387.scene_instance.json", + "./1/ProcTHOR-Test-731.scene_instance.json", + "./1/ProcTHOR-Test-700.scene_instance.json", + "./1/ProcTHOR-Test-242.scene_instance.json", + "./1/ProcTHOR-Test-415.scene_instance.json", + "./1/ProcTHOR-Test-366.scene_instance.json", + "./1/ProcTHOR-Test-955.scene_instance.json", + "./1/ProcTHOR-Test-473.scene_instance.json", + "./1/ProcTHOR-Test-708.scene_instance.json", + "./1/ProcTHOR-Test-830.scene_instance.json", + "./1/ProcTHOR-Test-320.scene_instance.json", + "./b/ProcTHOR-Train-9486.scene_instance.json", + "./b/ProcTHOR-Train-9468.scene_instance.json", + "./b/ProcTHOR-Train-9585.scene_instance.json", + "./b/ProcTHOR-Train-9195.scene_instance.json", + "./b/ProcTHOR-Train-9906.scene_instance.json", + "./b/ProcTHOR-Train-9447.scene_instance.json", + "./b/ProcTHOR-Train-9779.scene_instance.json", + "./b/ProcTHOR-Train-9697.scene_instance.json", + "./b/ProcTHOR-Train-9096.scene_instance.json", + "./b/ProcTHOR-Train-9878.scene_instance.json", + "./b/ProcTHOR-Train-9883.scene_instance.json", + "./b/ProcTHOR-Train-9376.scene_instance.json", + "./b/ProcTHOR-Train-9826.scene_instance.json", + "./b/ProcTHOR-Train-9379.scene_instance.json", + "./b/ProcTHOR-Train-9408.scene_instance.json", + "./b/ProcTHOR-Train-9311.scene_instance.json", + "./b/ProcTHOR-Train-9684.scene_instance.json", + "./b/ProcTHOR-Train-9903.scene_instance.json", + "./b/ProcTHOR-Train-9802.scene_instance.json", + "./b/ProcTHOR-Train-9221.scene_instance.json", + "./b/ProcTHOR-Train-9280.scene_instance.json", + "./b/ProcTHOR-Train-9578.scene_instance.json", + "./b/ProcTHOR-Train-9699.scene_instance.json", + "./b/ProcTHOR-Train-9677.scene_instance.json", + "./b/ProcTHOR-Train-9942.scene_instance.json", + "./b/ProcTHOR-Train-9222.scene_instance.json", + "./b/ProcTHOR-Train-9932.scene_instance.json", + "./b/ProcTHOR-Train-9077.scene_instance.json", + "./b/ProcTHOR-Train-9822.scene_instance.json", + "./b/ProcTHOR-Train-9089.scene_instance.json", + "./b/ProcTHOR-Train-9306.scene_instance.json", + "./b/ProcTHOR-Train-9774.scene_instance.json", + "./b/ProcTHOR-Train-9218.scene_instance.json", + "./b/ProcTHOR-Train-9018.scene_instance.json", + "./b/ProcTHOR-Train-9495.scene_instance.json", + "./b/ProcTHOR-Train-9481.scene_instance.json", + "./b/ProcTHOR-Train-9665.scene_instance.json", + "./b/ProcTHOR-Train-9871.scene_instance.json", + "./b/ProcTHOR-Train-9594.scene_instance.json", + "./b/ProcTHOR-Train-9947.scene_instance.json", + "./b/ProcTHOR-Train-9238.scene_instance.json", + "./b/ProcTHOR-Train-9804.scene_instance.json", + "./b/ProcTHOR-Train-9698.scene_instance.json", + "./b/ProcTHOR-Train-9307.scene_instance.json", + "./b/ProcTHOR-Train-9577.scene_instance.json", + "./b/ProcTHOR-Train-9317.scene_instance.json", + "./b/ProcTHOR-Train-9322.scene_instance.json", + "./b/ProcTHOR-Train-9584.scene_instance.json", + "./b/ProcTHOR-Train-9245.scene_instance.json", + "./b/ProcTHOR-Train-9359.scene_instance.json", + "./b/ProcTHOR-Train-9803.scene_instance.json", + "./b/ProcTHOR-Train-9615.scene_instance.json", + "./b/ProcTHOR-Train-9537.scene_instance.json", + "./b/ProcTHOR-Train-9913.scene_instance.json", + "./b/ProcTHOR-Train-9430.scene_instance.json", + "./b/ProcTHOR-Train-9695.scene_instance.json", + "./b/ProcTHOR-Train-9225.scene_instance.json", + "./b/ProcTHOR-Train-9208.scene_instance.json", + "./b/ProcTHOR-Train-9569.scene_instance.json", + "./b/ProcTHOR-Train-9991.scene_instance.json", + "./b/ProcTHOR-Train-9192.scene_instance.json", + "./b/ProcTHOR-Train-9433.scene_instance.json", + "./b/ProcTHOR-Train-9326.scene_instance.json", + "./b/ProcTHOR-Train-9092.scene_instance.json", + "./b/ProcTHOR-Train-9254.scene_instance.json", + "./b/ProcTHOR-Train-9063.scene_instance.json", + "./b/ProcTHOR-Train-9888.scene_instance.json", + "./b/ProcTHOR-Train-9264.scene_instance.json", + "./b/ProcTHOR-Train-9592.scene_instance.json", + "./b/ProcTHOR-Train-9213.scene_instance.json", + "./b/ProcTHOR-Train-9821.scene_instance.json", + "./b/ProcTHOR-Train-9709.scene_instance.json", + "./b/ProcTHOR-Train-9674.scene_instance.json", + "./b/ProcTHOR-Train-9288.scene_instance.json", + "./b/ProcTHOR-Train-9801.scene_instance.json", + "./b/ProcTHOR-Train-9360.scene_instance.json", + "./b/ProcTHOR-Train-9485.scene_instance.json", + "./b/ProcTHOR-Train-9180.scene_instance.json", + "./b/ProcTHOR-Train-9237.scene_instance.json", + "./b/ProcTHOR-Train-9338.scene_instance.json", + "./b/ProcTHOR-Train-9062.scene_instance.json", + "./b/ProcTHOR-Train-9762.scene_instance.json", + "./b/ProcTHOR-Train-9591.scene_instance.json", + "./b/ProcTHOR-Train-9197.scene_instance.json", + "./b/ProcTHOR-Train-9242.scene_instance.json", + "./b/ProcTHOR-Train-9934.scene_instance.json", + "./b/ProcTHOR-Train-9030.scene_instance.json", + "./b/ProcTHOR-Train-9038.scene_instance.json", + "./b/ProcTHOR-Train-9391.scene_instance.json", + "./b/ProcTHOR-Train-9623.scene_instance.json", + "./b/ProcTHOR-Train-9641.scene_instance.json", + "./b/ProcTHOR-Train-9339.scene_instance.json", + "./b/ProcTHOR-Train-9896.scene_instance.json", + "./b/ProcTHOR-Train-9503.scene_instance.json", + "./b/ProcTHOR-Train-9567.scene_instance.json", + "./b/ProcTHOR-Train-9406.scene_instance.json", + "./b/ProcTHOR-Train-9103.scene_instance.json", + "./b/ProcTHOR-Train-9756.scene_instance.json", + "./b/ProcTHOR-Train-9744.scene_instance.json", + "./b/ProcTHOR-Train-9836.scene_instance.json", + "./b/ProcTHOR-Train-9993.scene_instance.json", + "./b/ProcTHOR-Train-9866.scene_instance.json", + "./b/ProcTHOR-Train-9869.scene_instance.json", + "./b/ProcTHOR-Train-9292.scene_instance.json", + "./b/ProcTHOR-Train-9916.scene_instance.json", + "./b/ProcTHOR-Train-9640.scene_instance.json", + "./b/ProcTHOR-Train-9171.scene_instance.json", + "./b/ProcTHOR-Train-9064.scene_instance.json", + "./b/ProcTHOR-Train-9086.scene_instance.json", + "./b/ProcTHOR-Train-9190.scene_instance.json", + "./b/ProcTHOR-Train-9257.scene_instance.json", + "./b/ProcTHOR-Train-9751.scene_instance.json", + "./b/ProcTHOR-Train-9122.scene_instance.json", + "./b/ProcTHOR-Train-9919.scene_instance.json", + "./b/ProcTHOR-Train-9593.scene_instance.json", + "./b/ProcTHOR-Train-9484.scene_instance.json", + "./b/ProcTHOR-Train-9867.scene_instance.json", + "./b/ProcTHOR-Train-9134.scene_instance.json", + "./b/ProcTHOR-Train-9410.scene_instance.json", + "./b/ProcTHOR-Train-9755.scene_instance.json", + "./b/ProcTHOR-Train-9129.scene_instance.json", + "./b/ProcTHOR-Train-9243.scene_instance.json", + "./b/ProcTHOR-Train-9049.scene_instance.json", + "./b/ProcTHOR-Train-9065.scene_instance.json", + "./b/ProcTHOR-Train-9741.scene_instance.json", + "./b/ProcTHOR-Train-9378.scene_instance.json", + "./b/ProcTHOR-Train-9126.scene_instance.json", + "./b/ProcTHOR-Train-9346.scene_instance.json", + "./b/ProcTHOR-Train-9110.scene_instance.json", + "./b/ProcTHOR-Train-9340.scene_instance.json", + "./b/ProcTHOR-Train-9402.scene_instance.json", + "./b/ProcTHOR-Train-9036.scene_instance.json", + "./b/ProcTHOR-Train-9737.scene_instance.json", + "./b/ProcTHOR-Train-9541.scene_instance.json", + "./b/ProcTHOR-Train-9928.scene_instance.json", + "./b/ProcTHOR-Train-9951.scene_instance.json", + "./b/ProcTHOR-Train-9287.scene_instance.json", + "./b/ProcTHOR-Train-9100.scene_instance.json", + "./b/ProcTHOR-Train-9138.scene_instance.json", + "./b/ProcTHOR-Train-9318.scene_instance.json", + "./b/ProcTHOR-Train-9090.scene_instance.json", + "./b/ProcTHOR-Train-9047.scene_instance.json", + "./b/ProcTHOR-Train-9977.scene_instance.json", + "./b/ProcTHOR-Train-9768.scene_instance.json", + "./b/ProcTHOR-Train-9487.scene_instance.json", + "./b/ProcTHOR-Train-9907.scene_instance.json", + "./b/ProcTHOR-Train-9191.scene_instance.json", + "./b/ProcTHOR-Train-9742.scene_instance.json", + "./b/ProcTHOR-Train-9305.scene_instance.json", + "./b/ProcTHOR-Train-9029.scene_instance.json", + "./b/ProcTHOR-Train-9625.scene_instance.json", + "./b/ProcTHOR-Train-9328.scene_instance.json", + "./b/ProcTHOR-Train-9776.scene_instance.json", + "./b/ProcTHOR-Train-9939.scene_instance.json", + "./b/ProcTHOR-Train-9716.scene_instance.json", + "./b/ProcTHOR-Train-9514.scene_instance.json", + "./b/ProcTHOR-Train-9313.scene_instance.json", + "./b/ProcTHOR-Train-9370.scene_instance.json", + "./b/ProcTHOR-Train-9128.scene_instance.json", + "./b/ProcTHOR-Train-9106.scene_instance.json", + "./b/ProcTHOR-Train-9679.scene_instance.json", + "./b/ProcTHOR-Train-9315.scene_instance.json", + "./b/ProcTHOR-Train-9471.scene_instance.json", + "./b/ProcTHOR-Train-9686.scene_instance.json", + "./b/ProcTHOR-Train-9630.scene_instance.json", + "./b/ProcTHOR-Train-9268.scene_instance.json", + "./b/ProcTHOR-Train-9364.scene_instance.json", + "./b/ProcTHOR-Train-9342.scene_instance.json", + "./b/ProcTHOR-Train-9924.scene_instance.json", + "./b/ProcTHOR-Train-9040.scene_instance.json", + "./b/ProcTHOR-Train-9320.scene_instance.json", + "./b/ProcTHOR-Train-9160.scene_instance.json", + "./b/ProcTHOR-Train-9813.scene_instance.json", + "./b/ProcTHOR-Train-9952.scene_instance.json", + "./b/ProcTHOR-Train-9230.scene_instance.json", + "./b/ProcTHOR-Train-9352.scene_instance.json", + "./b/ProcTHOR-Train-9149.scene_instance.json", + "./b/ProcTHOR-Train-9337.scene_instance.json", + "./b/ProcTHOR-Train-9608.scene_instance.json", + "./b/ProcTHOR-Train-9163.scene_instance.json", + "./b/ProcTHOR-Train-9353.scene_instance.json", + "./b/ProcTHOR-Train-9810.scene_instance.json", + "./b/ProcTHOR-Train-9950.scene_instance.json", + "./b/ProcTHOR-Train-9571.scene_instance.json", + "./b/ProcTHOR-Train-9743.scene_instance.json", + "./b/ProcTHOR-Train-9579.scene_instance.json", + "./b/ProcTHOR-Train-9373.scene_instance.json", + "./b/ProcTHOR-Train-9590.scene_instance.json", + "./b/ProcTHOR-Train-9998.scene_instance.json", + "./b/ProcTHOR-Train-9900.scene_instance.json", + "./b/ProcTHOR-Train-9945.scene_instance.json", + "./b/ProcTHOR-Train-9764.scene_instance.json", + "./b/ProcTHOR-Train-9613.scene_instance.json", + "./b/ProcTHOR-Train-9148.scene_instance.json", + "./b/ProcTHOR-Train-9748.scene_instance.json", + "./b/ProcTHOR-Train-9035.scene_instance.json", + "./b/ProcTHOR-Train-9786.scene_instance.json", + "./b/ProcTHOR-Train-9582.scene_instance.json", + "./b/ProcTHOR-Train-9543.scene_instance.json", + "./b/ProcTHOR-Train-9943.scene_instance.json", + "./b/ProcTHOR-Train-9972.scene_instance.json", + "./b/ProcTHOR-Train-9689.scene_instance.json", + "./b/ProcTHOR-Train-9650.scene_instance.json", + "./b/ProcTHOR-Train-9941.scene_instance.json", + "./b/ProcTHOR-Train-9690.scene_instance.json", + "./b/ProcTHOR-Train-9173.scene_instance.json", + "./b/ProcTHOR-Train-9773.scene_instance.json", + "./b/ProcTHOR-Train-9277.scene_instance.json", + "./b/ProcTHOR-Train-9789.scene_instance.json", + "./b/ProcTHOR-Train-9884.scene_instance.json", + "./b/ProcTHOR-Train-9135.scene_instance.json", + "./b/ProcTHOR-Train-9583.scene_instance.json", + "./b/ProcTHOR-Train-9068.scene_instance.json", + "./b/ProcTHOR-Train-9217.scene_instance.json", + "./b/ProcTHOR-Train-9407.scene_instance.json", + "./b/ProcTHOR-Train-9067.scene_instance.json", + "./b/ProcTHOR-Train-9464.scene_instance.json", + "./b/ProcTHOR-Train-9416.scene_instance.json", + "./b/ProcTHOR-Train-9457.scene_instance.json", + "./b/ProcTHOR-Train-9759.scene_instance.json", + "./b/ProcTHOR-Train-9414.scene_instance.json", + "./b/ProcTHOR-Train-9177.scene_instance.json", + "./b/ProcTHOR-Train-9108.scene_instance.json", + "./b/ProcTHOR-Train-9925.scene_instance.json", + "./b/ProcTHOR-Train-9066.scene_instance.json", + "./b/ProcTHOR-Train-9849.scene_instance.json", + "./b/ProcTHOR-Train-9249.scene_instance.json", + "./b/ProcTHOR-Train-9385.scene_instance.json", + "./b/ProcTHOR-Train-9024.scene_instance.json", + "./b/ProcTHOR-Train-9862.scene_instance.json", + "./b/ProcTHOR-Train-9165.scene_instance.json", + "./b/ProcTHOR-Train-9636.scene_instance.json", + "./b/ProcTHOR-Train-9905.scene_instance.json", + "./b/ProcTHOR-Train-9185.scene_instance.json", + "./b/ProcTHOR-Train-9887.scene_instance.json", + "./b/ProcTHOR-Train-9140.scene_instance.json", + "./b/ProcTHOR-Train-9893.scene_instance.json", + "./b/ProcTHOR-Train-9022.scene_instance.json", + "./b/ProcTHOR-Train-9298.scene_instance.json", + "./b/ProcTHOR-Train-9452.scene_instance.json", + "./b/ProcTHOR-Train-9052.scene_instance.json", + "./b/ProcTHOR-Train-9073.scene_instance.json", + "./b/ProcTHOR-Train-9498.scene_instance.json", + "./b/ProcTHOR-Train-9691.scene_instance.json", + "./b/ProcTHOR-Train-9442.scene_instance.json", + "./b/ProcTHOR-Train-9226.scene_instance.json", + "./b/ProcTHOR-Train-9319.scene_instance.json", + "./b/ProcTHOR-Train-9266.scene_instance.json", + "./b/ProcTHOR-Train-9388.scene_instance.json", + "./b/ProcTHOR-Train-9864.scene_instance.json", + "./b/ProcTHOR-Train-9504.scene_instance.json", + "./b/ProcTHOR-Train-9383.scene_instance.json", + "./b/ProcTHOR-Train-9281.scene_instance.json", + "./b/ProcTHOR-Train-9095.scene_instance.json", + "./b/ProcTHOR-Train-9858.scene_instance.json", + "./b/ProcTHOR-Train-9472.scene_instance.json", + "./b/ProcTHOR-Train-9568.scene_instance.json", + "./b/ProcTHOR-Train-9124.scene_instance.json", + "./b/ProcTHOR-Train-9104.scene_instance.json", + "./b/ProcTHOR-Train-9975.scene_instance.json", + "./b/ProcTHOR-Train-9558.scene_instance.json", + "./b/ProcTHOR-Train-9521.scene_instance.json", + "./b/ProcTHOR-Train-9738.scene_instance.json", + "./b/ProcTHOR-Train-9749.scene_instance.json", + "./b/ProcTHOR-Train-9519.scene_instance.json", + "./b/ProcTHOR-Train-9028.scene_instance.json", + "./b/ProcTHOR-Train-9827.scene_instance.json", + "./b/ProcTHOR-Train-9812.scene_instance.json", + "./b/ProcTHOR-Train-9170.scene_instance.json", + "./b/ProcTHOR-Train-9467.scene_instance.json", + "./b/ProcTHOR-Train-9428.scene_instance.json", + "./b/ProcTHOR-Train-9588.scene_instance.json", + "./b/ProcTHOR-Train-9130.scene_instance.json", + "./b/ProcTHOR-Train-9099.scene_instance.json", + "./b/ProcTHOR-Train-9700.scene_instance.json", + "./b/ProcTHOR-Train-9248.scene_instance.json", + "./b/ProcTHOR-Train-9097.scene_instance.json", + "./b/ProcTHOR-Train-9816.scene_instance.json", + "./b/ProcTHOR-Train-9187.scene_instance.json", + "./b/ProcTHOR-Train-9788.scene_instance.json", + "./b/ProcTHOR-Train-9397.scene_instance.json", + "./b/ProcTHOR-Train-9714.scene_instance.json", + "./b/ProcTHOR-Train-9211.scene_instance.json", + "./b/ProcTHOR-Train-9719.scene_instance.json", + "./b/ProcTHOR-Train-9518.scene_instance.json", + "./b/ProcTHOR-Train-9336.scene_instance.json", + "./b/ProcTHOR-Train-9279.scene_instance.json", + "./b/ProcTHOR-Train-9161.scene_instance.json", + "./b/ProcTHOR-Train-9555.scene_instance.json", + "./b/ProcTHOR-Train-9227.scene_instance.json", + "./b/ProcTHOR-Train-9409.scene_instance.json", + "./b/ProcTHOR-Train-9216.scene_instance.json", + "./b/ProcTHOR-Train-9469.scene_instance.json", + "./b/ProcTHOR-Train-9278.scene_instance.json", + "./b/ProcTHOR-Train-9043.scene_instance.json", + "./b/ProcTHOR-Train-9435.scene_instance.json", + "./b/ProcTHOR-Train-9045.scene_instance.json", + "./b/ProcTHOR-Train-9809.scene_instance.json", + "./b/ProcTHOR-Train-9223.scene_instance.json", + "./b/ProcTHOR-Train-9971.scene_instance.json", + "./b/ProcTHOR-Train-9633.scene_instance.json", + "./b/ProcTHOR-Train-9439.scene_instance.json", + "./b/ProcTHOR-Train-9865.scene_instance.json", + "./b/ProcTHOR-Train-9752.scene_instance.json", + "./b/ProcTHOR-Train-9780.scene_instance.json", + "./b/ProcTHOR-Train-9329.scene_instance.json", + "./b/ProcTHOR-Train-9344.scene_instance.json", + "./b/ProcTHOR-Train-9377.scene_instance.json", + "./b/ProcTHOR-Train-9800.scene_instance.json", + "./b/ProcTHOR-Train-9986.scene_instance.json", + "./b/ProcTHOR-Train-9256.scene_instance.json", + "./b/ProcTHOR-Train-9499.scene_instance.json", + "./b/ProcTHOR-Train-9308.scene_instance.json", + "./b/ProcTHOR-Train-9694.scene_instance.json", + "./b/ProcTHOR-Train-9026.scene_instance.json", + "./b/ProcTHOR-Train-9790.scene_instance.json", + "./b/ProcTHOR-Train-9403.scene_instance.json", + "./b/ProcTHOR-Train-9401.scene_instance.json", + "./b/ProcTHOR-Train-9053.scene_instance.json", + "./b/ProcTHOR-Train-9111.scene_instance.json", + "./b/ProcTHOR-Train-9685.scene_instance.json", + "./b/ProcTHOR-Train-9997.scene_instance.json", + "./b/ProcTHOR-Train-9060.scene_instance.json", + "./b/ProcTHOR-Train-9244.scene_instance.json", + "./b/ProcTHOR-Train-9413.scene_instance.json", + "./b/ProcTHOR-Train-9123.scene_instance.json", + "./b/ProcTHOR-Train-9105.scene_instance.json", + "./b/ProcTHOR-Train-9396.scene_instance.json", + "./b/ProcTHOR-Train-9915.scene_instance.json", + "./b/ProcTHOR-Train-9441.scene_instance.json", + "./b/ProcTHOR-Train-9369.scene_instance.json", + "./b/ProcTHOR-Train-9164.scene_instance.json", + "./b/ProcTHOR-Train-9808.scene_instance.json", + "./b/ProcTHOR-Train-9892.scene_instance.json", + "./b/ProcTHOR-Train-9186.scene_instance.json", + "./b/ProcTHOR-Train-9059.scene_instance.json", + "./b/ProcTHOR-Train-9159.scene_instance.json", + "./b/ProcTHOR-Train-9841.scene_instance.json", + "./b/ProcTHOR-Train-9814.scene_instance.json", + "./b/ProcTHOR-Train-9276.scene_instance.json", + "./b/ProcTHOR-Train-9596.scene_instance.json", + "./b/ProcTHOR-Train-9247.scene_instance.json", + "./b/ProcTHOR-Train-9851.scene_instance.json", + "./b/ProcTHOR-Train-9879.scene_instance.json", + "./b/ProcTHOR-Train-9618.scene_instance.json", + "./b/ProcTHOR-Train-9670.scene_instance.json", + "./b/ProcTHOR-Train-9659.scene_instance.json", + "./b/ProcTHOR-Train-9299.scene_instance.json", + "./b/ProcTHOR-Train-9458.scene_instance.json", + "./b/ProcTHOR-Train-9312.scene_instance.json", + "./b/ProcTHOR-Train-9958.scene_instance.json", + "./b/ProcTHOR-Train-9725.scene_instance.json", + "./b/ProcTHOR-Train-9158.scene_instance.json", + "./b/ProcTHOR-Train-9923.scene_instance.json", + "./b/ProcTHOR-Train-9877.scene_instance.json", + "./b/ProcTHOR-Train-9070.scene_instance.json", + "./b/ProcTHOR-Train-9446.scene_instance.json", + "./b/ProcTHOR-Train-9420.scene_instance.json", + "./b/ProcTHOR-Train-9451.scene_instance.json", + "./b/ProcTHOR-Train-9933.scene_instance.json", + "./b/ProcTHOR-Train-9151.scene_instance.json", + "./b/ProcTHOR-Train-9056.scene_instance.json", + "./b/ProcTHOR-Train-9450.scene_instance.json", + "./b/ProcTHOR-Train-9423.scene_instance.json", + "./b/ProcTHOR-Train-9707.scene_instance.json", + "./b/ProcTHOR-Train-9666.scene_instance.json", + "./b/ProcTHOR-Train-9363.scene_instance.json", + "./b/ProcTHOR-Train-9232.scene_instance.json", + "./b/ProcTHOR-Train-9508.scene_instance.json", + "./b/ProcTHOR-Train-9898.scene_instance.json", + "./b/ProcTHOR-Train-9710.scene_instance.json", + "./b/ProcTHOR-Train-9109.scene_instance.json", + "./b/ProcTHOR-Train-9194.scene_instance.json", + "./b/ProcTHOR-Train-9005.scene_instance.json", + "./b/ProcTHOR-Train-9260.scene_instance.json", + "./b/ProcTHOR-Train-9931.scene_instance.json", + "./b/ProcTHOR-Train-9604.scene_instance.json", + "./b/ProcTHOR-Train-9241.scene_instance.json", + "./b/ProcTHOR-Train-9270.scene_instance.json", + "./b/ProcTHOR-Train-9325.scene_instance.json", + "./b/ProcTHOR-Train-9890.scene_instance.json", + "./b/ProcTHOR-Train-9411.scene_instance.json", + "./b/ProcTHOR-Train-9429.scene_instance.json", + "./b/ProcTHOR-Train-9404.scene_instance.json", + "./b/ProcTHOR-Train-9791.scene_instance.json", + "./b/ProcTHOR-Train-9502.scene_instance.json", + "./b/ProcTHOR-Train-9460.scene_instance.json", + "./b/ProcTHOR-Train-9154.scene_instance.json", + "./b/ProcTHOR-Train-9091.scene_instance.json", + "./b/ProcTHOR-Train-9094.scene_instance.json", + "./b/ProcTHOR-Train-9881.scene_instance.json", + "./b/ProcTHOR-Train-9580.scene_instance.json", + "./b/ProcTHOR-Train-9012.scene_instance.json", + "./b/ProcTHOR-Train-9601.scene_instance.json", + "./b/ProcTHOR-Train-9720.scene_instance.json", + "./b/ProcTHOR-Train-9523.scene_instance.json", + "./b/ProcTHOR-Train-9145.scene_instance.json", + "./b/ProcTHOR-Train-9120.scene_instance.json", + "./b/ProcTHOR-Train-9978.scene_instance.json", + "./b/ProcTHOR-Train-9054.scene_instance.json", + "./b/ProcTHOR-Train-9549.scene_instance.json", + "./b/ProcTHOR-Train-9642.scene_instance.json", + "./b/ProcTHOR-Train-9753.scene_instance.json", + "./b/ProcTHOR-Train-9846.scene_instance.json", + "./b/ProcTHOR-Train-9335.scene_instance.json", + "./b/ProcTHOR-Train-9652.scene_instance.json", + "./b/ProcTHOR-Train-9635.scene_instance.json", + "./b/ProcTHOR-Train-9711.scene_instance.json", + "./b/ProcTHOR-Train-9265.scene_instance.json", + "./b/ProcTHOR-Train-9522.scene_instance.json", + "./b/ProcTHOR-Train-9343.scene_instance.json", + "./b/ProcTHOR-Train-9365.scene_instance.json", + "./b/ProcTHOR-Train-9285.scene_instance.json", + "./b/ProcTHOR-Train-9990.scene_instance.json", + "./b/ProcTHOR-Train-9178.scene_instance.json", + "./b/ProcTHOR-Train-9463.scene_instance.json", + "./b/ProcTHOR-Train-9074.scene_instance.json", + "./b/ProcTHOR-Train-9882.scene_instance.json", + "./b/ProcTHOR-Train-9290.scene_instance.json", + "./b/ProcTHOR-Train-9107.scene_instance.json", + "./b/ProcTHOR-Train-9009.scene_instance.json", + "./b/ProcTHOR-Train-9200.scene_instance.json", + "./b/ProcTHOR-Train-9229.scene_instance.json", + "./b/ProcTHOR-Train-9852.scene_instance.json", + "./b/ProcTHOR-Train-9374.scene_instance.json", + "./b/ProcTHOR-Train-9917.scene_instance.json", + "./b/ProcTHOR-Train-9013.scene_instance.json", + "./b/ProcTHOR-Train-9112.scene_instance.json", + "./b/ProcTHOR-Train-9600.scene_instance.json", + "./b/ProcTHOR-Train-9296.scene_instance.json", + "./b/ProcTHOR-Train-9683.scene_instance.json", + "./b/ProcTHOR-Train-9424.scene_instance.json", + "./b/ProcTHOR-Train-9078.scene_instance.json", + "./b/ProcTHOR-Train-9770.scene_instance.json", + "./b/ProcTHOR-Train-9020.scene_instance.json", + "./b/ProcTHOR-Train-9586.scene_instance.json", + "./b/ProcTHOR-Train-9393.scene_instance.json", + "./b/ProcTHOR-Train-9769.scene_instance.json", + "./b/ProcTHOR-Train-9115.scene_instance.json", + "./b/ProcTHOR-Train-9638.scene_instance.json", + "./b/ProcTHOR-Train-9034.scene_instance.json", + "./b/ProcTHOR-Train-9560.scene_instance.json", + "./b/ProcTHOR-Train-9525.scene_instance.json", + "./b/ProcTHOR-Train-9209.scene_instance.json", + "./b/ProcTHOR-Train-9426.scene_instance.json", + "./b/ProcTHOR-Train-9283.scene_instance.json", + "./b/ProcTHOR-Train-9069.scene_instance.json", + "./b/ProcTHOR-Train-9007.scene_instance.json", + "./b/ProcTHOR-Train-9168.scene_instance.json", + "./b/ProcTHOR-Train-9565.scene_instance.json", + "./b/ProcTHOR-Train-9616.scene_instance.json", + "./b/ProcTHOR-Train-9422.scene_instance.json", + "./b/ProcTHOR-Train-9282.scene_instance.json", + "./b/ProcTHOR-Train-9848.scene_instance.json", + "./b/ProcTHOR-Train-9350.scene_instance.json", + "./b/ProcTHOR-Train-9793.scene_instance.json", + "./b/ProcTHOR-Train-9688.scene_instance.json", + "./b/ProcTHOR-Train-9713.scene_instance.json", + "./b/ProcTHOR-Train-9671.scene_instance.json", + "./b/ProcTHOR-Train-9207.scene_instance.json", + "./b/ProcTHOR-Train-9563.scene_instance.json", + "./b/ProcTHOR-Train-9644.scene_instance.json", + "./b/ProcTHOR-Train-9267.scene_instance.json", + "./b/ProcTHOR-Train-9682.scene_instance.json", + "./b/ProcTHOR-Train-9908.scene_instance.json", + "./b/ProcTHOR-Train-9261.scene_instance.json", + "./b/ProcTHOR-Train-9874.scene_instance.json", + "./b/ProcTHOR-Train-9143.scene_instance.json", + "./b/ProcTHOR-Train-9072.scene_instance.json", + "./b/ProcTHOR-Train-9845.scene_instance.json", + "./b/ProcTHOR-Train-9739.scene_instance.json", + "./b/ProcTHOR-Train-9844.scene_instance.json", + "./b/ProcTHOR-Train-9039.scene_instance.json", + "./b/ProcTHOR-Train-9627.scene_instance.json", + "./b/ProcTHOR-Train-9489.scene_instance.json", + "./b/ProcTHOR-Train-9015.scene_instance.json", + "./b/ProcTHOR-Train-9984.scene_instance.json", + "./b/ProcTHOR-Train-9775.scene_instance.json", + "./b/ProcTHOR-Train-9235.scene_instance.json", + "./b/ProcTHOR-Train-9488.scene_instance.json", + "./b/ProcTHOR-Train-9930.scene_instance.json", + "./b/ProcTHOR-Train-9621.scene_instance.json", + "./b/ProcTHOR-Train-9512.scene_instance.json", + "./b/ProcTHOR-Train-9981.scene_instance.json", + "./b/ProcTHOR-Train-9566.scene_instance.json", + "./b/ProcTHOR-Train-9956.scene_instance.json", + "./b/ProcTHOR-Train-9825.scene_instance.json", + "./b/ProcTHOR-Train-9902.scene_instance.json", + "./b/ProcTHOR-Train-9316.scene_instance.json", + "./b/ProcTHOR-Train-9204.scene_instance.json", + "./b/ProcTHOR-Train-9357.scene_instance.json", + "./b/ProcTHOR-Train-9263.scene_instance.json", + "./b/ProcTHOR-Train-9819.scene_instance.json", + "./b/ProcTHOR-Train-9784.scene_instance.json", + "./b/ProcTHOR-Train-9556.scene_instance.json", + "./b/ProcTHOR-Train-9837.scene_instance.json", + "./b/ProcTHOR-Train-9911.scene_instance.json", + "./b/ProcTHOR-Train-9546.scene_instance.json", + "./b/ProcTHOR-Train-9548.scene_instance.json", + "./b/ProcTHOR-Train-9607.scene_instance.json", + "./b/ProcTHOR-Train-9031.scene_instance.json", + "./b/ProcTHOR-Train-9004.scene_instance.json", + "./b/ProcTHOR-Train-9272.scene_instance.json", + "./b/ProcTHOR-Train-9936.scene_instance.json", + "./b/ProcTHOR-Train-9437.scene_instance.json", + "./b/ProcTHOR-Train-9157.scene_instance.json", + "./b/ProcTHOR-Train-9019.scene_instance.json", + "./b/ProcTHOR-Train-9119.scene_instance.json", + "./b/ProcTHOR-Train-9729.scene_instance.json", + "./b/ProcTHOR-Train-9701.scene_instance.json", + "./b/ProcTHOR-Train-9201.scene_instance.json", + "./b/ProcTHOR-Train-9381.scene_instance.json", + "./b/ProcTHOR-Train-9146.scene_instance.json", + "./b/ProcTHOR-Train-9075.scene_instance.json", + "./b/ProcTHOR-Train-9703.scene_instance.json", + "./b/ProcTHOR-Train-9136.scene_instance.json", + "./b/ProcTHOR-Train-9189.scene_instance.json", + "./b/ProcTHOR-Train-9531.scene_instance.json", + "./b/ProcTHOR-Train-9992.scene_instance.json", + "./b/ProcTHOR-Train-9944.scene_instance.json", + "./b/ProcTHOR-Train-9490.scene_instance.json", + "./b/ProcTHOR-Train-9632.scene_instance.json", + "./b/ProcTHOR-Train-9961.scene_instance.json", + "./b/ProcTHOR-Train-9875.scene_instance.json", + "./b/ProcTHOR-Train-9766.scene_instance.json", + "./b/ProcTHOR-Train-9114.scene_instance.json", + "./b/ProcTHOR-Train-9920.scene_instance.json", + "./b/ProcTHOR-Train-9395.scene_instance.json", + "./b/ProcTHOR-Train-9765.scene_instance.json", + "./b/ProcTHOR-Train-9345.scene_instance.json", + "./b/ProcTHOR-Train-9101.scene_instance.json", + "./b/ProcTHOR-Train-9740.scene_instance.json", + "./b/ProcTHOR-Train-9876.scene_instance.json", + "./b/ProcTHOR-Train-9643.scene_instance.json", + "./b/ProcTHOR-Train-9366.scene_instance.json", + "./b/ProcTHOR-Train-9647.scene_instance.json", + "./b/ProcTHOR-Train-9964.scene_instance.json", + "./b/ProcTHOR-Train-9672.scene_instance.json", + "./b/ProcTHOR-Train-9561.scene_instance.json", + "./b/ProcTHOR-Train-9387.scene_instance.json", + "./b/ProcTHOR-Train-9718.scene_instance.json", + "./b/ProcTHOR-Train-9479.scene_instance.json", + "./b/ProcTHOR-Train-9175.scene_instance.json", + "./b/ProcTHOR-Train-9361.scene_instance.json", + "./b/ProcTHOR-Train-9210.scene_instance.json", + "./b/ProcTHOR-Train-9735.scene_instance.json", + "./b/ProcTHOR-Train-9988.scene_instance.json", + "./b/ProcTHOR-Train-9922.scene_instance.json", + "./b/ProcTHOR-Train-9079.scene_instance.json", + "./b/ProcTHOR-Train-9431.scene_instance.json", + "./b/ProcTHOR-Train-9899.scene_instance.json", + "./b/ProcTHOR-Train-9717.scene_instance.json", + "./b/ProcTHOR-Train-9760.scene_instance.json", + "./b/ProcTHOR-Train-9444.scene_instance.json", + "./b/ProcTHOR-Train-9542.scene_instance.json", + "./b/ProcTHOR-Train-9083.scene_instance.json", + "./b/ProcTHOR-Train-9959.scene_instance.json", + "./b/ProcTHOR-Train-9331.scene_instance.json", + "./b/ProcTHOR-Train-9927.scene_instance.json", + "./b/ProcTHOR-Train-9494.scene_instance.json", + "./b/ProcTHOR-Train-9382.scene_instance.json", + "./b/ProcTHOR-Train-9347.scene_instance.json", + "./b/ProcTHOR-Train-9071.scene_instance.json", + "./b/ProcTHOR-Train-9246.scene_instance.json", + "./b/ProcTHOR-Train-9001.scene_instance.json", + "./b/ProcTHOR-Train-9732.scene_instance.json", + "./b/ProcTHOR-Train-9427.scene_instance.json", + "./b/ProcTHOR-Train-9141.scene_instance.json", + "./b/ProcTHOR-Train-9660.scene_instance.json", + "./b/ProcTHOR-Train-9767.scene_instance.json", + "./b/ProcTHOR-Train-9389.scene_instance.json", + "./b/ProcTHOR-Train-9645.scene_instance.json", + "./b/ProcTHOR-Train-9777.scene_instance.json", + "./b/ProcTHOR-Train-9771.scene_instance.json", + "./b/ProcTHOR-Train-9334.scene_instance.json", + "./b/ProcTHOR-Train-9966.scene_instance.json", + "./b/ProcTHOR-Train-9220.scene_instance.json", + "./b/ProcTHOR-Train-9309.scene_instance.json", + "./b/ProcTHOR-Train-9754.scene_instance.json", + "./b/ProcTHOR-Train-9605.scene_instance.json", + "./b/ProcTHOR-Train-9736.scene_instance.json", + "./b/ProcTHOR-Train-9155.scene_instance.json", + "./b/ProcTHOR-Train-9273.scene_instance.json", + "./b/ProcTHOR-Train-9872.scene_instance.json", + "./b/ProcTHOR-Train-9949.scene_instance.json", + "./b/ProcTHOR-Train-9117.scene_instance.json", + "./b/ProcTHOR-Train-9914.scene_instance.json", + "./b/ProcTHOR-Train-9527.scene_instance.json", + "./b/ProcTHOR-Train-9873.scene_instance.json", + "./b/ProcTHOR-Train-9861.scene_instance.json", + "./b/ProcTHOR-Train-9289.scene_instance.json", + "./b/ProcTHOR-Train-9262.scene_instance.json", + "./b/ProcTHOR-Train-9967.scene_instance.json", + "./b/ProcTHOR-Train-9006.scene_instance.json", + "./b/ProcTHOR-Train-9624.scene_instance.json", + "./b/ProcTHOR-Train-9310.scene_instance.json", + "./b/ProcTHOR-Train-9962.scene_instance.json", + "./b/ProcTHOR-Train-9448.scene_instance.json", + "./b/ProcTHOR-Train-9188.scene_instance.json", + "./b/ProcTHOR-Train-9693.scene_instance.json", + "./b/ProcTHOR-Train-9017.scene_instance.json", + "./b/ProcTHOR-Train-9653.scene_instance.json", + "./b/ProcTHOR-Train-9573.scene_instance.json", + "./b/ProcTHOR-Train-9901.scene_instance.json", + "./b/ProcTHOR-Train-9133.scene_instance.json", + "./b/ProcTHOR-Train-9797.scene_instance.json", + "./b/ProcTHOR-Train-9734.scene_instance.json", + "./b/ProcTHOR-Train-9595.scene_instance.json", + "./b/ProcTHOR-Train-9628.scene_instance.json", + "./b/ProcTHOR-Train-9897.scene_instance.json", + "./b/ProcTHOR-Train-9676.scene_instance.json", + "./b/ProcTHOR-Train-9889.scene_instance.json", + "./b/ProcTHOR-Train-9985.scene_instance.json", + "./b/ProcTHOR-Train-9559.scene_instance.json", + "./b/ProcTHOR-Train-9655.scene_instance.json", + "./b/ProcTHOR-Train-9182.scene_instance.json", + "./b/ProcTHOR-Train-9181.scene_instance.json", + "./b/ProcTHOR-Train-9545.scene_instance.json", + "./b/ProcTHOR-Train-9704.scene_instance.json", + "./b/ProcTHOR-Train-9910.scene_instance.json", + "./b/ProcTHOR-Train-9349.scene_instance.json", + "./b/ProcTHOR-Train-9176.scene_instance.json", + "./b/ProcTHOR-Train-9868.scene_instance.json", + "./b/ProcTHOR-Train-9598.scene_instance.json", + "./b/ProcTHOR-Train-9973.scene_instance.json", + "./b/ProcTHOR-Train-9792.scene_instance.json", + "./b/ProcTHOR-Train-9438.scene_instance.json", + "./b/ProcTHOR-Train-9576.scene_instance.json", + "./b/ProcTHOR-Train-9473.scene_instance.json", + "./b/ProcTHOR-Train-9667.scene_instance.json", + "./b/ProcTHOR-Train-9929.scene_instance.json", + "./b/ProcTHOR-Train-9758.scene_instance.json", + "./b/ProcTHOR-Train-9547.scene_instance.json", + "./b/ProcTHOR-Train-9839.scene_instance.json", + "./b/ProcTHOR-Train-9044.scene_instance.json", + "./b/ProcTHOR-Train-9172.scene_instance.json", + "./b/ProcTHOR-Train-9712.scene_instance.json", + "./b/ProcTHOR-Train-9405.scene_instance.json", + "./b/ProcTHOR-Train-9297.scene_instance.json", + "./b/ProcTHOR-Train-9506.scene_instance.json", + "./b/ProcTHOR-Train-9828.scene_instance.json", + "./b/ProcTHOR-Train-9612.scene_instance.json", + "./b/ProcTHOR-Train-9156.scene_instance.json", + "./b/ProcTHOR-Train-9412.scene_instance.json", + "./b/ProcTHOR-Train-9082.scene_instance.json", + "./b/ProcTHOR-Train-9418.scene_instance.json", + "./b/ProcTHOR-Train-9417.scene_instance.json", + "./b/ProcTHOR-Train-9462.scene_instance.json", + "./b/ProcTHOR-Train-9918.scene_instance.json", + "./b/ProcTHOR-Train-9507.scene_instance.json", + "./b/ProcTHOR-Train-9622.scene_instance.json", + "./b/ProcTHOR-Train-9649.scene_instance.json", + "./b/ProcTHOR-Train-9696.scene_instance.json", + "./b/ProcTHOR-Train-9747.scene_instance.json", + "./b/ProcTHOR-Train-9400.scene_instance.json", + "./b/ProcTHOR-Train-9116.scene_instance.json", + "./b/ProcTHOR-Train-9912.scene_instance.json", + "./b/ProcTHOR-Train-9639.scene_instance.json", + "./b/ProcTHOR-Train-9515.scene_instance.json", + "./b/ProcTHOR-Train-9833.scene_instance.json", + "./b/ProcTHOR-Train-9497.scene_instance.json", + "./b/ProcTHOR-Train-9478.scene_instance.json", + "./b/ProcTHOR-Train-9757.scene_instance.json", + "./b/ProcTHOR-Train-9611.scene_instance.json", + "./b/ProcTHOR-Train-9805.scene_instance.json", + "./b/ProcTHOR-Train-9654.scene_instance.json", + "./b/ProcTHOR-Train-9603.scene_instance.json", + "./b/ProcTHOR-Train-9002.scene_instance.json", + "./b/ProcTHOR-Train-9572.scene_instance.json", + "./b/ProcTHOR-Train-9785.scene_instance.json", + "./b/ProcTHOR-Train-9184.scene_instance.json", + "./b/ProcTHOR-Train-9935.scene_instance.json", + "./b/ProcTHOR-Train-9894.scene_instance.json", + "./b/ProcTHOR-Train-9974.scene_instance.json", + "./b/ProcTHOR-Train-9678.scene_instance.json", + "./b/ProcTHOR-Train-9084.scene_instance.json", + "./b/ProcTHOR-Train-9153.scene_instance.json", + "./b/ProcTHOR-Train-9505.scene_instance.json", + "./b/ProcTHOR-Train-9857.scene_instance.json", + "./b/ProcTHOR-Train-9436.scene_instance.json", + "./b/ProcTHOR-Train-9392.scene_instance.json", + "./b/ProcTHOR-Train-9021.scene_instance.json", + "./b/ProcTHOR-Train-9323.scene_instance.json", + "./b/ProcTHOR-Train-9557.scene_instance.json", + "./b/ProcTHOR-Train-9231.scene_instance.json", + "./b/ProcTHOR-Train-9554.scene_instance.json", + "./b/ProcTHOR-Train-9274.scene_instance.json", + "./b/ProcTHOR-Train-9386.scene_instance.json", + "./b/ProcTHOR-Train-9937.scene_instance.json", + "./b/ProcTHOR-Train-9702.scene_instance.json", + "./b/ProcTHOR-Train-9166.scene_instance.json", + "./b/ProcTHOR-Train-9144.scene_instance.json", + "./b/ProcTHOR-Train-9687.scene_instance.json", + "./b/ProcTHOR-Train-9540.scene_instance.json", + "./b/ProcTHOR-Train-9562.scene_instance.json", + "./b/ProcTHOR-Train-9443.scene_instance.json", + "./b/ProcTHOR-Train-9098.scene_instance.json", + "./b/ProcTHOR-Train-9253.scene_instance.json", + "./b/ProcTHOR-Train-9125.scene_instance.json", + "./b/ProcTHOR-Train-9233.scene_instance.json", + "./b/ProcTHOR-Train-9656.scene_instance.json", + "./b/ProcTHOR-Train-9745.scene_instance.json", + "./b/ProcTHOR-Train-9394.scene_instance.json", + "./b/ProcTHOR-Train-9390.scene_instance.json", + "./b/ProcTHOR-Train-9509.scene_instance.json", + "./b/ProcTHOR-Train-9926.scene_instance.json", + "./b/ProcTHOR-Train-9658.scene_instance.json", + "./b/ProcTHOR-Train-9610.scene_instance.json", + "./b/ProcTHOR-Train-9152.scene_instance.json", + "./b/ProcTHOR-Train-9587.scene_instance.json", + "./b/ProcTHOR-Train-9832.scene_instance.json", + "./b/ProcTHOR-Train-9955.scene_instance.json", + "./b/ProcTHOR-Train-9599.scene_instance.json", + "./b/ProcTHOR-Train-9746.scene_instance.json", + "./b/ProcTHOR-Train-9787.scene_instance.json", + "./b/ProcTHOR-Train-9996.scene_instance.json", + "./b/ProcTHOR-Train-9474.scene_instance.json", + "./b/ProcTHOR-Train-9480.scene_instance.json", + "./b/ProcTHOR-Train-9842.scene_instance.json", + "./b/ProcTHOR-Train-9076.scene_instance.json", + "./b/ProcTHOR-Train-9629.scene_instance.json", + "./b/ProcTHOR-Train-9979.scene_instance.json", + "./b/ProcTHOR-Train-9139.scene_instance.json", + "./b/ProcTHOR-Train-9778.scene_instance.json", + "./b/ProcTHOR-Train-9137.scene_instance.json", + "./b/ProcTHOR-Train-9258.scene_instance.json", + "./b/ProcTHOR-Train-9534.scene_instance.json", + "./b/ProcTHOR-Train-9219.scene_instance.json", + "./b/ProcTHOR-Train-9661.scene_instance.json", + "./b/ProcTHOR-Train-9212.scene_instance.json", + "./b/ProcTHOR-Train-9662.scene_instance.json", + "./b/ProcTHOR-Train-9199.scene_instance.json", + "./b/ProcTHOR-Train-9025.scene_instance.json", + "./b/ProcTHOR-Train-9536.scene_instance.json", + "./b/ProcTHOR-Train-9432.scene_instance.json", + "./b/ProcTHOR-Train-9061.scene_instance.json", + "./b/ProcTHOR-Train-9609.scene_instance.json", + "./b/ProcTHOR-Train-9147.scene_instance.json", + "./b/ProcTHOR-Train-9142.scene_instance.json", + "./b/ProcTHOR-Train-9003.scene_instance.json", + "./b/ProcTHOR-Train-9570.scene_instance.json", + "./b/ProcTHOR-Train-9824.scene_instance.json", + "./b/ProcTHOR-Train-9300.scene_instance.json", + "./b/ProcTHOR-Train-9058.scene_instance.json", + "./b/ProcTHOR-Train-9946.scene_instance.json", + "./b/ProcTHOR-Train-9174.scene_instance.json", + "./b/ProcTHOR-Train-9850.scene_instance.json", + "./b/ProcTHOR-Train-9728.scene_instance.json", + "./b/ProcTHOR-Train-9354.scene_instance.json", + "./b/ProcTHOR-Train-9830.scene_instance.json", + "./b/ProcTHOR-Train-9648.scene_instance.json", + "./b/ProcTHOR-Train-9783.scene_instance.json", + "./b/ProcTHOR-Train-9445.scene_instance.json", + "./b/ProcTHOR-Train-9838.scene_instance.json", + "./b/ProcTHOR-Train-9513.scene_instance.json", + "./b/ProcTHOR-Train-9526.scene_instance.json", + "./b/ProcTHOR-Train-9327.scene_instance.json", + "./b/ProcTHOR-Train-9948.scene_instance.json", + "./b/ProcTHOR-Train-9461.scene_instance.json", + "./b/ProcTHOR-Train-9511.scene_instance.json", + "./b/ProcTHOR-Train-9517.scene_instance.json", + "./b/ProcTHOR-Train-9193.scene_instance.json", + "./b/ProcTHOR-Train-9477.scene_instance.json", + "./b/ProcTHOR-Train-9302.scene_instance.json", + "./b/ProcTHOR-Train-9938.scene_instance.json", + "./b/ProcTHOR-Train-9016.scene_instance.json", + "./b/ProcTHOR-Train-9169.scene_instance.json", + "./b/ProcTHOR-Train-9203.scene_instance.json", + "./b/ProcTHOR-Train-9330.scene_instance.json", + "./b/ProcTHOR-Train-9453.scene_instance.json", + "./b/ProcTHOR-Train-9372.scene_instance.json", + "./b/ProcTHOR-Train-9118.scene_instance.json", + "./b/ProcTHOR-Train-9501.scene_instance.json", + "./b/ProcTHOR-Train-9657.scene_instance.json", + "./b/ProcTHOR-Train-9492.scene_instance.json", + "./b/ProcTHOR-Train-9399.scene_instance.json", + "./b/ProcTHOR-Train-9380.scene_instance.json", + "./b/ProcTHOR-Train-9269.scene_instance.json", + "./b/ProcTHOR-Train-9529.scene_instance.json", + "./b/ProcTHOR-Train-9301.scene_instance.json", + "./b/ProcTHOR-Train-9476.scene_instance.json", + "./b/ProcTHOR-Train-9856.scene_instance.json", + "./b/ProcTHOR-Train-9834.scene_instance.json", + "./b/ProcTHOR-Train-9252.scene_instance.json", + "./b/ProcTHOR-Train-9081.scene_instance.json", + "./b/ProcTHOR-Train-9886.scene_instance.json", + "./b/ProcTHOR-Train-9722.scene_instance.json", + "./b/ProcTHOR-Train-9606.scene_instance.json", + "./b/ProcTHOR-Train-9750.scene_instance.json", + "./b/ProcTHOR-Train-9995.scene_instance.json", + "./b/ProcTHOR-Train-9341.scene_instance.json", + "./b/ProcTHOR-Train-9798.scene_instance.json", + "./b/ProcTHOR-Train-9909.scene_instance.json", + "./b/ProcTHOR-Train-9651.scene_instance.json", + "./b/ProcTHOR-Train-9799.scene_instance.json", + "./b/ProcTHOR-Train-9113.scene_instance.json", + "./b/ProcTHOR-Train-9880.scene_instance.json", + "./b/ProcTHOR-Train-9847.scene_instance.json", + "./b/ProcTHOR-Train-9419.scene_instance.json", + "./b/ProcTHOR-Train-9675.scene_instance.json", + "./b/ProcTHOR-Train-9332.scene_instance.json", + "./b/ProcTHOR-Train-9375.scene_instance.json", + "./b/ProcTHOR-Train-9960.scene_instance.json", + "./b/ProcTHOR-Train-9080.scene_instance.json", + "./b/ProcTHOR-Train-9131.scene_instance.json", + "./b/ProcTHOR-Train-9620.scene_instance.json", + "./b/ProcTHOR-Train-9980.scene_instance.json", + "./b/ProcTHOR-Train-9669.scene_instance.json", + "./b/ProcTHOR-Train-9000.scene_instance.json", + "./b/ProcTHOR-Train-9835.scene_instance.json", + "./b/ProcTHOR-Train-9150.scene_instance.json", + "./b/ProcTHOR-Train-9807.scene_instance.json", + "./b/ProcTHOR-Train-9724.scene_instance.json", + "./b/ProcTHOR-Train-9863.scene_instance.json", + "./b/ProcTHOR-Train-9224.scene_instance.json", + "./b/ProcTHOR-Train-9355.scene_instance.json", + "./b/ProcTHOR-Train-9384.scene_instance.json", + "./b/ProcTHOR-Train-9983.scene_instance.json", + "./b/ProcTHOR-Train-9859.scene_instance.json", + "./b/ProcTHOR-Train-9968.scene_instance.json", + "./b/ProcTHOR-Train-9121.scene_instance.json", + "./b/ProcTHOR-Train-9538.scene_instance.json", + "./b/ProcTHOR-Train-9293.scene_instance.json", + "./b/ProcTHOR-Train-9093.scene_instance.json", + "./b/ProcTHOR-Train-9761.scene_instance.json", + "./b/ProcTHOR-Train-9733.scene_instance.json", + "./b/ProcTHOR-Train-9356.scene_instance.json", + "./b/ProcTHOR-Train-9042.scene_instance.json", + "./b/ProcTHOR-Train-9895.scene_instance.json", + "./b/ProcTHOR-Train-9705.scene_instance.json", + "./b/ProcTHOR-Train-9023.scene_instance.json", + "./b/ProcTHOR-Train-9721.scene_instance.json", + "./b/ProcTHOR-Train-9617.scene_instance.json", + "./b/ProcTHOR-Train-9011.scene_instance.json", + "./b/ProcTHOR-Train-9324.scene_instance.json", + "./b/ProcTHOR-Train-9198.scene_instance.json", + "./b/ProcTHOR-Train-9183.scene_instance.json", + "./b/ProcTHOR-Train-9730.scene_instance.json", + "./b/ProcTHOR-Train-9552.scene_instance.json", + "./b/ProcTHOR-Train-9050.scene_instance.json", + "./b/ProcTHOR-Train-9398.scene_instance.json", + "./b/ProcTHOR-Train-9614.scene_instance.json", + "./b/ProcTHOR-Train-9333.scene_instance.json", + "./b/ProcTHOR-Train-9853.scene_instance.json", + "./b/ProcTHOR-Train-9680.scene_instance.json", + "./b/ProcTHOR-Train-9637.scene_instance.json", + "./b/ProcTHOR-Train-9772.scene_instance.json", + "./b/ProcTHOR-Train-9994.scene_instance.json", + "./b/ProcTHOR-Train-9010.scene_instance.json", + "./b/ProcTHOR-Train-9524.scene_instance.json", + "./b/ProcTHOR-Train-9673.scene_instance.json", + "./b/ProcTHOR-Train-9957.scene_instance.json", + "./b/ProcTHOR-Train-9963.scene_instance.json", + "./b/ProcTHOR-Train-9668.scene_instance.json", + "./b/ProcTHOR-Train-9706.scene_instance.json", + "./b/ProcTHOR-Train-9860.scene_instance.json", + "./b/ProcTHOR-Train-9415.scene_instance.json", + "./b/ProcTHOR-Train-9321.scene_instance.json", + "./b/ProcTHOR-Train-9589.scene_instance.json", + "./b/ProcTHOR-Train-9055.scene_instance.json", + "./b/ProcTHOR-Train-9348.scene_instance.json", + "./b/ProcTHOR-Train-9535.scene_instance.json", + "./b/ProcTHOR-Train-9564.scene_instance.json", + "./b/ProcTHOR-Train-9236.scene_instance.json", + "./b/ProcTHOR-Train-9482.scene_instance.json", + "./b/ProcTHOR-Train-9132.scene_instance.json", + "./b/ProcTHOR-Train-9048.scene_instance.json", + "./b/ProcTHOR-Train-9470.scene_instance.json", + "./b/ProcTHOR-Train-9976.scene_instance.json", + "./b/ProcTHOR-Train-9581.scene_instance.json", + "./b/ProcTHOR-Train-9794.scene_instance.json", + "./b/ProcTHOR-Train-9820.scene_instance.json", + "./b/ProcTHOR-Train-9027.scene_instance.json", + "./b/ProcTHOR-Train-9551.scene_instance.json", + "./b/ProcTHOR-Train-9575.scene_instance.json", + "./b/ProcTHOR-Train-9806.scene_instance.json", + "./b/ProcTHOR-Train-9202.scene_instance.json", + "./b/ProcTHOR-Train-9033.scene_instance.json", + "./b/ProcTHOR-Train-9259.scene_instance.json", + "./b/ProcTHOR-Train-9727.scene_instance.json", + "./b/ProcTHOR-Train-9510.scene_instance.json", + "./b/ProcTHOR-Train-9516.scene_instance.json", + "./b/ProcTHOR-Train-9855.scene_instance.json", + "./b/ProcTHOR-Train-9969.scene_instance.json", + "./b/ProcTHOR-Train-9483.scene_instance.json", + "./b/ProcTHOR-Train-9251.scene_instance.json", + "./b/ProcTHOR-Train-9041.scene_instance.json", + "./b/ProcTHOR-Train-9811.scene_instance.json", + "./b/ProcTHOR-Train-9303.scene_instance.json", + "./b/ProcTHOR-Train-9368.scene_instance.json", + "./b/ProcTHOR-Train-9544.scene_instance.json", + "./b/ProcTHOR-Train-9014.scene_instance.json", + "./b/ProcTHOR-Train-9465.scene_instance.json", + "./b/ProcTHOR-Train-9631.scene_instance.json", + "./b/ProcTHOR-Train-9763.scene_instance.json", + "./b/ProcTHOR-Train-9294.scene_instance.json", + "./b/ProcTHOR-Train-9634.scene_instance.json", + "./b/ProcTHOR-Train-9553.scene_instance.json", + "./b/ProcTHOR-Train-9434.scene_instance.json", + "./b/ProcTHOR-Train-9271.scene_instance.json", + "./b/ProcTHOR-Train-9214.scene_instance.json", + "./b/ProcTHOR-Train-9454.scene_instance.json", + "./b/ProcTHOR-Train-9127.scene_instance.json", + "./b/ProcTHOR-Train-9240.scene_instance.json", + "./b/ProcTHOR-Train-9362.scene_instance.json", + "./b/ProcTHOR-Train-9008.scene_instance.json", + "./b/ProcTHOR-Train-9795.scene_instance.json", + "./b/ProcTHOR-Train-9102.scene_instance.json", + "./b/ProcTHOR-Train-9179.scene_instance.json", + "./b/ProcTHOR-Train-9455.scene_instance.json", + "./b/ProcTHOR-Train-9440.scene_instance.json", + "./b/ProcTHOR-Train-9304.scene_instance.json", + "./b/ProcTHOR-Train-9574.scene_instance.json", + "./b/ProcTHOR-Train-9456.scene_instance.json", + "./b/ProcTHOR-Train-9351.scene_instance.json", + "./b/ProcTHOR-Train-9664.scene_instance.json", + "./b/ProcTHOR-Train-9466.scene_instance.json", + "./b/ProcTHOR-Train-9239.scene_instance.json", + "./b/ProcTHOR-Train-9250.scene_instance.json", + "./b/ProcTHOR-Train-9840.scene_instance.json", + "./b/ProcTHOR-Train-9449.scene_instance.json", + "./b/ProcTHOR-Train-9831.scene_instance.json", + "./b/ProcTHOR-Train-9295.scene_instance.json", + "./b/ProcTHOR-Train-9051.scene_instance.json", + "./b/ProcTHOR-Train-9731.scene_instance.json", + "./b/ProcTHOR-Train-9496.scene_instance.json", + "./b/ProcTHOR-Train-9646.scene_instance.json", + "./b/ProcTHOR-Train-9921.scene_instance.json", + "./b/ProcTHOR-Train-9085.scene_instance.json", + "./b/ProcTHOR-Train-9829.scene_instance.json", + "./b/ProcTHOR-Train-9275.scene_instance.json", + "./b/ProcTHOR-Train-9037.scene_instance.json", + "./b/ProcTHOR-Train-9782.scene_instance.json", + "./b/ProcTHOR-Train-9954.scene_instance.json", + "./b/ProcTHOR-Train-9781.scene_instance.json", + "./b/ProcTHOR-Train-9314.scene_instance.json", + "./b/ProcTHOR-Train-9500.scene_instance.json", + "./b/ProcTHOR-Train-9205.scene_instance.json", + "./b/ProcTHOR-Train-9371.scene_instance.json", + "./b/ProcTHOR-Train-9970.scene_instance.json", + "./b/ProcTHOR-Train-9358.scene_instance.json", + "./b/ProcTHOR-Train-9999.scene_instance.json", + "./b/ProcTHOR-Train-9708.scene_instance.json", + "./b/ProcTHOR-Train-9196.scene_instance.json", + "./b/ProcTHOR-Train-9843.scene_instance.json", + "./b/ProcTHOR-Train-9234.scene_instance.json", + "./b/ProcTHOR-Train-9723.scene_instance.json", + "./b/ProcTHOR-Train-9904.scene_instance.json", + "./b/ProcTHOR-Train-9284.scene_instance.json", + "./b/ProcTHOR-Train-9087.scene_instance.json", + "./b/ProcTHOR-Train-9817.scene_instance.json", + "./b/ProcTHOR-Train-9619.scene_instance.json", + "./b/ProcTHOR-Train-9162.scene_instance.json", + "./b/ProcTHOR-Train-9602.scene_instance.json", + "./b/ProcTHOR-Train-9885.scene_instance.json", + "./b/ProcTHOR-Train-9206.scene_instance.json", + "./b/ProcTHOR-Train-9520.scene_instance.json", + "./b/ProcTHOR-Train-9425.scene_instance.json", + "./b/ProcTHOR-Train-9823.scene_instance.json", + "./b/ProcTHOR-Train-9692.scene_instance.json", + "./b/ProcTHOR-Train-9032.scene_instance.json", + "./b/ProcTHOR-Train-9965.scene_instance.json", + "./b/ProcTHOR-Train-9715.scene_instance.json", + "./b/ProcTHOR-Train-9550.scene_instance.json", + "./b/ProcTHOR-Train-9533.scene_instance.json", + "./b/ProcTHOR-Train-9528.scene_instance.json", + "./b/ProcTHOR-Train-9286.scene_instance.json", + "./b/ProcTHOR-Train-9982.scene_instance.json", + "./b/ProcTHOR-Train-9818.scene_instance.json", + "./b/ProcTHOR-Train-9597.scene_instance.json", + "./b/ProcTHOR-Train-9215.scene_instance.json", + "./b/ProcTHOR-Train-9796.scene_instance.json", + "./b/ProcTHOR-Train-9854.scene_instance.json", + "./b/ProcTHOR-Train-9088.scene_instance.json", + "./b/ProcTHOR-Train-9530.scene_instance.json", + "./b/ProcTHOR-Train-9367.scene_instance.json", + "./b/ProcTHOR-Train-9626.scene_instance.json", + "./b/ProcTHOR-Train-9539.scene_instance.json", + "./b/ProcTHOR-Train-9681.scene_instance.json", + "./b/ProcTHOR-Train-9459.scene_instance.json", + "./b/ProcTHOR-Train-9989.scene_instance.json", + "./b/ProcTHOR-Train-9953.scene_instance.json", + "./b/ProcTHOR-Train-9891.scene_instance.json", + "./b/ProcTHOR-Train-9940.scene_instance.json", + "./b/ProcTHOR-Train-9726.scene_instance.json", + "./b/ProcTHOR-Train-9663.scene_instance.json", + "./b/ProcTHOR-Train-9493.scene_instance.json", + "./b/ProcTHOR-Train-9046.scene_instance.json", + "./b/ProcTHOR-Train-9987.scene_instance.json", + "./b/ProcTHOR-Train-9167.scene_instance.json", + "./b/ProcTHOR-Train-9421.scene_instance.json", + "./b/ProcTHOR-Train-9255.scene_instance.json", + "./b/ProcTHOR-Train-9815.scene_instance.json", + "./b/ProcTHOR-Train-9228.scene_instance.json", + "./b/ProcTHOR-Train-9475.scene_instance.json", + "./b/ProcTHOR-Train-9870.scene_instance.json", + "./b/ProcTHOR-Train-9532.scene_instance.json", + "./b/ProcTHOR-Train-9491.scene_instance.json", + "./b/ProcTHOR-Train-9057.scene_instance.json", + "./b/ProcTHOR-Train-9291.scene_instance.json", + "./9/ProcTHOR-Train-7909.scene_instance.json", + "./9/ProcTHOR-Train-7501.scene_instance.json", + "./9/ProcTHOR-Train-7002.scene_instance.json", + "./9/ProcTHOR-Train-7941.scene_instance.json", + "./9/ProcTHOR-Train-7789.scene_instance.json", + "./9/ProcTHOR-Train-7347.scene_instance.json", + "./9/ProcTHOR-Train-7181.scene_instance.json", + "./9/ProcTHOR-Train-7334.scene_instance.json", + "./9/ProcTHOR-Train-7525.scene_instance.json", + "./9/ProcTHOR-Train-7019.scene_instance.json", + "./9/ProcTHOR-Train-7021.scene_instance.json", + "./9/ProcTHOR-Train-7412.scene_instance.json", + "./9/ProcTHOR-Train-7996.scene_instance.json", + "./9/ProcTHOR-Train-7064.scene_instance.json", + "./9/ProcTHOR-Train-7503.scene_instance.json", + "./9/ProcTHOR-Train-7107.scene_instance.json", + "./9/ProcTHOR-Train-7834.scene_instance.json", + "./9/ProcTHOR-Train-7361.scene_instance.json", + "./9/ProcTHOR-Train-7483.scene_instance.json", + "./9/ProcTHOR-Train-7003.scene_instance.json", + "./9/ProcTHOR-Train-7781.scene_instance.json", + "./9/ProcTHOR-Train-7442.scene_instance.json", + "./9/ProcTHOR-Train-7523.scene_instance.json", + "./9/ProcTHOR-Train-7280.scene_instance.json", + "./9/ProcTHOR-Train-7422.scene_instance.json", + "./9/ProcTHOR-Train-7708.scene_instance.json", + "./9/ProcTHOR-Train-7234.scene_instance.json", + "./9/ProcTHOR-Train-7879.scene_instance.json", + "./9/ProcTHOR-Train-7030.scene_instance.json", + "./9/ProcTHOR-Train-7677.scene_instance.json", + "./9/ProcTHOR-Train-7626.scene_instance.json", + "./9/ProcTHOR-Train-7227.scene_instance.json", + "./9/ProcTHOR-Train-7451.scene_instance.json", + "./9/ProcTHOR-Train-7652.scene_instance.json", + "./9/ProcTHOR-Train-7548.scene_instance.json", + "./9/ProcTHOR-Train-7513.scene_instance.json", + "./9/ProcTHOR-Train-7210.scene_instance.json", + "./9/ProcTHOR-Train-7452.scene_instance.json", + "./9/ProcTHOR-Train-7832.scene_instance.json", + "./9/ProcTHOR-Train-7415.scene_instance.json", + "./9/ProcTHOR-Train-7490.scene_instance.json", + "./9/ProcTHOR-Train-7920.scene_instance.json", + "./9/ProcTHOR-Train-7146.scene_instance.json", + "./9/ProcTHOR-Train-7357.scene_instance.json", + "./9/ProcTHOR-Train-7229.scene_instance.json", + "./9/ProcTHOR-Train-7160.scene_instance.json", + "./9/ProcTHOR-Train-7588.scene_instance.json", + "./9/ProcTHOR-Train-7358.scene_instance.json", + "./9/ProcTHOR-Train-7516.scene_instance.json", + "./9/ProcTHOR-Train-7702.scene_instance.json", + "./9/ProcTHOR-Train-7157.scene_instance.json", + "./9/ProcTHOR-Train-7968.scene_instance.json", + "./9/ProcTHOR-Train-7517.scene_instance.json", + "./9/ProcTHOR-Train-7887.scene_instance.json", + "./9/ProcTHOR-Train-7919.scene_instance.json", + "./9/ProcTHOR-Train-7521.scene_instance.json", + "./9/ProcTHOR-Train-7605.scene_instance.json", + "./9/ProcTHOR-Train-7831.scene_instance.json", + "./9/ProcTHOR-Train-7641.scene_instance.json", + "./9/ProcTHOR-Train-7805.scene_instance.json", + "./9/ProcTHOR-Train-7828.scene_instance.json", + "./9/ProcTHOR-Train-7328.scene_instance.json", + "./9/ProcTHOR-Train-7738.scene_instance.json", + "./9/ProcTHOR-Train-7850.scene_instance.json", + "./9/ProcTHOR-Train-7806.scene_instance.json", + "./9/ProcTHOR-Train-7394.scene_instance.json", + "./9/ProcTHOR-Train-7700.scene_instance.json", + "./9/ProcTHOR-Train-7899.scene_instance.json", + "./9/ProcTHOR-Train-7662.scene_instance.json", + "./9/ProcTHOR-Train-7291.scene_instance.json", + "./9/ProcTHOR-Train-7559.scene_instance.json", + "./9/ProcTHOR-Train-7759.scene_instance.json", + "./9/ProcTHOR-Train-7597.scene_instance.json", + "./9/ProcTHOR-Train-7897.scene_instance.json", + "./9/ProcTHOR-Train-7659.scene_instance.json", + "./9/ProcTHOR-Train-7873.scene_instance.json", + "./9/ProcTHOR-Train-7006.scene_instance.json", + "./9/ProcTHOR-Train-7175.scene_instance.json", + "./9/ProcTHOR-Train-7311.scene_instance.json", + "./9/ProcTHOR-Train-7603.scene_instance.json", + "./9/ProcTHOR-Train-7301.scene_instance.json", + "./9/ProcTHOR-Train-7286.scene_instance.json", + "./9/ProcTHOR-Train-7621.scene_instance.json", + "./9/ProcTHOR-Train-7277.scene_instance.json", + "./9/ProcTHOR-Train-7790.scene_instance.json", + "./9/ProcTHOR-Train-7981.scene_instance.json", + "./9/ProcTHOR-Train-7952.scene_instance.json", + "./9/ProcTHOR-Train-7821.scene_instance.json", + "./9/ProcTHOR-Train-7173.scene_instance.json", + "./9/ProcTHOR-Train-7562.scene_instance.json", + "./9/ProcTHOR-Train-7261.scene_instance.json", + "./9/ProcTHOR-Train-7195.scene_instance.json", + "./9/ProcTHOR-Train-7565.scene_instance.json", + "./9/ProcTHOR-Train-7686.scene_instance.json", + "./9/ProcTHOR-Train-7803.scene_instance.json", + "./9/ProcTHOR-Train-7174.scene_instance.json", + "./9/ProcTHOR-Train-7374.scene_instance.json", + "./9/ProcTHOR-Train-7314.scene_instance.json", + "./9/ProcTHOR-Train-7801.scene_instance.json", + "./9/ProcTHOR-Train-7654.scene_instance.json", + "./9/ProcTHOR-Train-7008.scene_instance.json", + "./9/ProcTHOR-Train-7735.scene_instance.json", + "./9/ProcTHOR-Train-7392.scene_instance.json", + "./9/ProcTHOR-Train-7213.scene_instance.json", + "./9/ProcTHOR-Train-7409.scene_instance.json", + "./9/ProcTHOR-Train-7531.scene_instance.json", + "./9/ProcTHOR-Train-7871.scene_instance.json", + "./9/ProcTHOR-Train-7299.scene_instance.json", + "./9/ProcTHOR-Train-7622.scene_instance.json", + "./9/ProcTHOR-Train-7440.scene_instance.json", + "./9/ProcTHOR-Train-7163.scene_instance.json", + "./9/ProcTHOR-Train-7294.scene_instance.json", + "./9/ProcTHOR-Train-7411.scene_instance.json", + "./9/ProcTHOR-Train-7441.scene_instance.json", + "./9/ProcTHOR-Train-7742.scene_instance.json", + "./9/ProcTHOR-Train-7323.scene_instance.json", + "./9/ProcTHOR-Train-7353.scene_instance.json", + "./9/ProcTHOR-Train-7882.scene_instance.json", + "./9/ProcTHOR-Train-7532.scene_instance.json", + "./9/ProcTHOR-Train-7551.scene_instance.json", + "./9/ProcTHOR-Train-7618.scene_instance.json", + "./9/ProcTHOR-Train-7072.scene_instance.json", + "./9/ProcTHOR-Train-7248.scene_instance.json", + "./9/ProcTHOR-Train-7444.scene_instance.json", + "./9/ProcTHOR-Train-7303.scene_instance.json", + "./9/ProcTHOR-Train-7913.scene_instance.json", + "./9/ProcTHOR-Train-7017.scene_instance.json", + "./9/ProcTHOR-Train-7947.scene_instance.json", + "./9/ProcTHOR-Train-7182.scene_instance.json", + "./9/ProcTHOR-Train-7090.scene_instance.json", + "./9/ProcTHOR-Train-7500.scene_instance.json", + "./9/ProcTHOR-Train-7782.scene_instance.json", + "./9/ProcTHOR-Train-7680.scene_instance.json", + "./9/ProcTHOR-Train-7109.scene_instance.json", + "./9/ProcTHOR-Train-7580.scene_instance.json", + "./9/ProcTHOR-Train-7487.scene_instance.json", + "./9/ProcTHOR-Train-7052.scene_instance.json", + "./9/ProcTHOR-Train-7676.scene_instance.json", + "./9/ProcTHOR-Train-7300.scene_instance.json", + "./9/ProcTHOR-Train-7650.scene_instance.json", + "./9/ProcTHOR-Train-7645.scene_instance.json", + "./9/ProcTHOR-Train-7660.scene_instance.json", + "./9/ProcTHOR-Train-7281.scene_instance.json", + "./9/ProcTHOR-Train-7020.scene_instance.json", + "./9/ProcTHOR-Train-7582.scene_instance.json", + "./9/ProcTHOR-Train-7371.scene_instance.json", + "./9/ProcTHOR-Train-7741.scene_instance.json", + "./9/ProcTHOR-Train-7204.scene_instance.json", + "./9/ProcTHOR-Train-7246.scene_instance.json", + "./9/ProcTHOR-Train-7854.scene_instance.json", + "./9/ProcTHOR-Train-7861.scene_instance.json", + "./9/ProcTHOR-Train-7867.scene_instance.json", + "./9/ProcTHOR-Train-7485.scene_instance.json", + "./9/ProcTHOR-Train-7672.scene_instance.json", + "./9/ProcTHOR-Train-7071.scene_instance.json", + "./9/ProcTHOR-Train-7454.scene_instance.json", + "./9/ProcTHOR-Train-7056.scene_instance.json", + "./9/ProcTHOR-Train-7846.scene_instance.json", + "./9/ProcTHOR-Train-7395.scene_instance.json", + "./9/ProcTHOR-Train-7259.scene_instance.json", + "./9/ProcTHOR-Train-7241.scene_instance.json", + "./9/ProcTHOR-Train-7417.scene_instance.json", + "./9/ProcTHOR-Train-7389.scene_instance.json", + "./9/ProcTHOR-Train-7351.scene_instance.json", + "./9/ProcTHOR-Train-7418.scene_instance.json", + "./9/ProcTHOR-Train-7581.scene_instance.json", + "./9/ProcTHOR-Train-7215.scene_instance.json", + "./9/ProcTHOR-Train-7282.scene_instance.json", + "./9/ProcTHOR-Train-7039.scene_instance.json", + "./9/ProcTHOR-Train-7914.scene_instance.json", + "./9/ProcTHOR-Train-7658.scene_instance.json", + "./9/ProcTHOR-Train-7461.scene_instance.json", + "./9/ProcTHOR-Train-7140.scene_instance.json", + "./9/ProcTHOR-Train-7344.scene_instance.json", + "./9/ProcTHOR-Train-7385.scene_instance.json", + "./9/ProcTHOR-Train-7318.scene_instance.json", + "./9/ProcTHOR-Train-7809.scene_instance.json", + "./9/ProcTHOR-Train-7903.scene_instance.json", + "./9/ProcTHOR-Train-7818.scene_instance.json", + "./9/ProcTHOR-Train-7206.scene_instance.json", + "./9/ProcTHOR-Train-7356.scene_instance.json", + "./9/ProcTHOR-Train-7339.scene_instance.json", + "./9/ProcTHOR-Train-7878.scene_instance.json", + "./9/ProcTHOR-Train-7578.scene_instance.json", + "./9/ProcTHOR-Train-7556.scene_instance.json", + "./9/ProcTHOR-Train-7737.scene_instance.json", + "./9/ProcTHOR-Train-7055.scene_instance.json", + "./9/ProcTHOR-Train-7577.scene_instance.json", + "./9/ProcTHOR-Train-7482.scene_instance.json", + "./9/ProcTHOR-Train-7904.scene_instance.json", + "./9/ProcTHOR-Train-7518.scene_instance.json", + "./9/ProcTHOR-Train-7127.scene_instance.json", + "./9/ProcTHOR-Train-7439.scene_instance.json", + "./9/ProcTHOR-Train-7373.scene_instance.json", + "./9/ProcTHOR-Train-7902.scene_instance.json", + "./9/ProcTHOR-Train-7527.scene_instance.json", + "./9/ProcTHOR-Train-7851.scene_instance.json", + "./9/ProcTHOR-Train-7928.scene_instance.json", + "./9/ProcTHOR-Train-7426.scene_instance.json", + "./9/ProcTHOR-Train-7321.scene_instance.json", + "./9/ProcTHOR-Train-7378.scene_instance.json", + "./9/ProcTHOR-Train-7091.scene_instance.json", + "./9/ProcTHOR-Train-7905.scene_instance.json", + "./9/ProcTHOR-Train-7571.scene_instance.json", + "./9/ProcTHOR-Train-7435.scene_instance.json", + "./9/ProcTHOR-Train-7080.scene_instance.json", + "./9/ProcTHOR-Train-7969.scene_instance.json", + "./9/ProcTHOR-Train-7710.scene_instance.json", + "./9/ProcTHOR-Train-7113.scene_instance.json", + "./9/ProcTHOR-Train-7794.scene_instance.json", + "./9/ProcTHOR-Train-7506.scene_instance.json", + "./9/ProcTHOR-Train-7927.scene_instance.json", + "./9/ProcTHOR-Train-7183.scene_instance.json", + "./9/ProcTHOR-Train-7197.scene_instance.json", + "./9/ProcTHOR-Train-7705.scene_instance.json", + "./9/ProcTHOR-Train-7857.scene_instance.json", + "./9/ProcTHOR-Train-7617.scene_instance.json", + "./9/ProcTHOR-Train-7279.scene_instance.json", + "./9/ProcTHOR-Train-7972.scene_instance.json", + "./9/ProcTHOR-Train-7137.scene_instance.json", + "./9/ProcTHOR-Train-7611.scene_instance.json", + "./9/ProcTHOR-Train-7596.scene_instance.json", + "./9/ProcTHOR-Train-7736.scene_instance.json", + "./9/ProcTHOR-Train-7688.scene_instance.json", + "./9/ProcTHOR-Train-7953.scene_instance.json", + "./9/ProcTHOR-Train-7685.scene_instance.json", + "./9/ProcTHOR-Train-7965.scene_instance.json", + "./9/ProcTHOR-Train-7000.scene_instance.json", + "./9/ProcTHOR-Train-7337.scene_instance.json", + "./9/ProcTHOR-Train-7424.scene_instance.json", + "./9/ProcTHOR-Train-7493.scene_instance.json", + "./9/ProcTHOR-Train-7159.scene_instance.json", + "./9/ProcTHOR-Train-7068.scene_instance.json", + "./9/ProcTHOR-Train-7203.scene_instance.json", + "./9/ProcTHOR-Train-7733.scene_instance.json", + "./9/ProcTHOR-Train-7226.scene_instance.json", + "./9/ProcTHOR-Train-7696.scene_instance.json", + "./9/ProcTHOR-Train-7792.scene_instance.json", + "./9/ProcTHOR-Train-7062.scene_instance.json", + "./9/ProcTHOR-Train-7031.scene_instance.json", + "./9/ProcTHOR-Train-7813.scene_instance.json", + "./9/ProcTHOR-Train-7752.scene_instance.json", + "./9/ProcTHOR-Train-7149.scene_instance.json", + "./9/ProcTHOR-Train-7960.scene_instance.json", + "./9/ProcTHOR-Train-7716.scene_instance.json", + "./9/ProcTHOR-Train-7096.scene_instance.json", + "./9/ProcTHOR-Train-7900.scene_instance.json", + "./9/ProcTHOR-Train-7024.scene_instance.json", + "./9/ProcTHOR-Train-7640.scene_instance.json", + "./9/ProcTHOR-Train-7362.scene_instance.json", + "./9/ProcTHOR-Train-7448.scene_instance.json", + "./9/ProcTHOR-Train-7092.scene_instance.json", + "./9/ProcTHOR-Train-7161.scene_instance.json", + "./9/ProcTHOR-Train-7860.scene_instance.json", + "./9/ProcTHOR-Train-7288.scene_instance.json", + "./9/ProcTHOR-Train-7791.scene_instance.json", + "./9/ProcTHOR-Train-7205.scene_instance.json", + "./9/ProcTHOR-Train-7812.scene_instance.json", + "./9/ProcTHOR-Train-7613.scene_instance.json", + "./9/ProcTHOR-Train-7931.scene_instance.json", + "./9/ProcTHOR-Train-7536.scene_instance.json", + "./9/ProcTHOR-Train-7232.scene_instance.json", + "./9/ProcTHOR-Train-7655.scene_instance.json", + "./9/ProcTHOR-Train-7896.scene_instance.json", + "./9/ProcTHOR-Train-7178.scene_instance.json", + "./9/ProcTHOR-Train-7491.scene_instance.json", + "./9/ProcTHOR-Train-7494.scene_instance.json", + "./9/ProcTHOR-Train-7937.scene_instance.json", + "./9/ProcTHOR-Train-7906.scene_instance.json", + "./9/ProcTHOR-Train-7446.scene_instance.json", + "./9/ProcTHOR-Train-7445.scene_instance.json", + "./9/ProcTHOR-Train-7088.scene_instance.json", + "./9/ProcTHOR-Train-7651.scene_instance.json", + "./9/ProcTHOR-Train-7082.scene_instance.json", + "./9/ProcTHOR-Train-7579.scene_instance.json", + "./9/ProcTHOR-Train-7022.scene_instance.json", + "./9/ProcTHOR-Train-7029.scene_instance.json", + "./9/ProcTHOR-Train-7172.scene_instance.json", + "./9/ProcTHOR-Train-7079.scene_instance.json", + "./9/ProcTHOR-Train-7763.scene_instance.json", + "./9/ProcTHOR-Train-7869.scene_instance.json", + "./9/ProcTHOR-Train-7788.scene_instance.json", + "./9/ProcTHOR-Train-7689.scene_instance.json", + "./9/ProcTHOR-Train-7774.scene_instance.json", + "./9/ProcTHOR-Train-7890.scene_instance.json", + "./9/ProcTHOR-Train-7322.scene_instance.json", + "./9/ProcTHOR-Train-7823.scene_instance.json", + "./9/ProcTHOR-Train-7973.scene_instance.json", + "./9/ProcTHOR-Train-7342.scene_instance.json", + "./9/ProcTHOR-Train-7416.scene_instance.json", + "./9/ProcTHOR-Train-7815.scene_instance.json", + "./9/ProcTHOR-Train-7623.scene_instance.json", + "./9/ProcTHOR-Train-7690.scene_instance.json", + "./9/ProcTHOR-Train-7036.scene_instance.json", + "./9/ProcTHOR-Train-7719.scene_instance.json", + "./9/ProcTHOR-Train-7268.scene_instance.json", + "./9/ProcTHOR-Train-7010.scene_instance.json", + "./9/ProcTHOR-Train-7643.scene_instance.json", + "./9/ProcTHOR-Train-7894.scene_instance.json", + "./9/ProcTHOR-Train-7892.scene_instance.json", + "./9/ProcTHOR-Train-7032.scene_instance.json", + "./9/ProcTHOR-Train-7001.scene_instance.json", + "./9/ProcTHOR-Train-7764.scene_instance.json", + "./9/ProcTHOR-Train-7661.scene_instance.json", + "./9/ProcTHOR-Train-7979.scene_instance.json", + "./9/ProcTHOR-Train-7907.scene_instance.json", + "./9/ProcTHOR-Train-7177.scene_instance.json", + "./9/ProcTHOR-Train-7609.scene_instance.json", + "./9/ProcTHOR-Train-7840.scene_instance.json", + "./9/ProcTHOR-Train-7228.scene_instance.json", + "./9/ProcTHOR-Train-7604.scene_instance.json", + "./9/ProcTHOR-Train-7040.scene_instance.json", + "./9/ProcTHOR-Train-7481.scene_instance.json", + "./9/ProcTHOR-Train-7408.scene_instance.json", + "./9/ProcTHOR-Train-7184.scene_instance.json", + "./9/ProcTHOR-Train-7350.scene_instance.json", + "./9/ProcTHOR-Train-7059.scene_instance.json", + "./9/ProcTHOR-Train-7935.scene_instance.json", + "./9/ProcTHOR-Train-7045.scene_instance.json", + "./9/ProcTHOR-Train-7567.scene_instance.json", + "./9/ProcTHOR-Train-7381.scene_instance.json", + "./9/ProcTHOR-Train-7401.scene_instance.json", + "./9/ProcTHOR-Train-7158.scene_instance.json", + "./9/ProcTHOR-Train-7612.scene_instance.json", + "./9/ProcTHOR-Train-7530.scene_instance.json", + "./9/ProcTHOR-Train-7455.scene_instance.json", + "./9/ProcTHOR-Train-7606.scene_instance.json", + "./9/ProcTHOR-Train-7058.scene_instance.json", + "./9/ProcTHOR-Train-7325.scene_instance.json", + "./9/ProcTHOR-Train-7876.scene_instance.json", + "./9/ProcTHOR-Train-7835.scene_instance.json", + "./9/ProcTHOR-Train-7383.scene_instance.json", + "./9/ProcTHOR-Train-7164.scene_instance.json", + "./9/ProcTHOR-Train-7547.scene_instance.json", + "./9/ProcTHOR-Train-7306.scene_instance.json", + "./9/ProcTHOR-Train-7678.scene_instance.json", + "./9/ProcTHOR-Train-7151.scene_instance.json", + "./9/ProcTHOR-Train-7212.scene_instance.json", + "./9/ProcTHOR-Train-7814.scene_instance.json", + "./9/ProcTHOR-Train-7666.scene_instance.json", + "./9/ProcTHOR-Train-7304.scene_instance.json", + "./9/ProcTHOR-Train-7138.scene_instance.json", + "./9/ProcTHOR-Train-7671.scene_instance.json", + "./9/ProcTHOR-Train-7706.scene_instance.json", + "./9/ProcTHOR-Train-7771.scene_instance.json", + "./9/ProcTHOR-Train-7698.scene_instance.json", + "./9/ProcTHOR-Train-7768.scene_instance.json", + "./9/ProcTHOR-Train-7893.scene_instance.json", + "./9/ProcTHOR-Train-7130.scene_instance.json", + "./9/ProcTHOR-Train-7196.scene_instance.json", + "./9/ProcTHOR-Train-7855.scene_instance.json", + "./9/ProcTHOR-Train-7829.scene_instance.json", + "./9/ProcTHOR-Train-7852.scene_instance.json", + "./9/ProcTHOR-Train-7936.scene_instance.json", + "./9/ProcTHOR-Train-7974.scene_instance.json", + "./9/ProcTHOR-Train-7592.scene_instance.json", + "./9/ProcTHOR-Train-7257.scene_instance.json", + "./9/ProcTHOR-Train-7238.scene_instance.json", + "./9/ProcTHOR-Train-7086.scene_instance.json", + "./9/ProcTHOR-Train-7386.scene_instance.json", + "./9/ProcTHOR-Train-7249.scene_instance.json", + "./9/ProcTHOR-Train-7346.scene_instance.json", + "./9/ProcTHOR-Train-7783.scene_instance.json", + "./9/ProcTHOR-Train-7629.scene_instance.json", + "./9/ProcTHOR-Train-7054.scene_instance.json", + "./9/ProcTHOR-Train-7743.scene_instance.json", + "./9/ProcTHOR-Train-7725.scene_instance.json", + "./9/ProcTHOR-Train-7796.scene_instance.json", + "./9/ProcTHOR-Train-7883.scene_instance.json", + "./9/ProcTHOR-Train-7984.scene_instance.json", + "./9/ProcTHOR-Train-7004.scene_instance.json", + "./9/ProcTHOR-Train-7192.scene_instance.json", + "./9/ProcTHOR-Train-7359.scene_instance.json", + "./9/ProcTHOR-Train-7060.scene_instance.json", + "./9/ProcTHOR-Train-7370.scene_instance.json", + "./9/ProcTHOR-Train-7870.scene_instance.json", + "./9/ProcTHOR-Train-7047.scene_instance.json", + "./9/ProcTHOR-Train-7307.scene_instance.json", + "./9/ProcTHOR-Train-7957.scene_instance.json", + "./9/ProcTHOR-Train-7224.scene_instance.json", + "./9/ProcTHOR-Train-7492.scene_instance.json", + "./9/ProcTHOR-Train-7825.scene_instance.json", + "./9/ProcTHOR-Train-7143.scene_instance.json", + "./9/ProcTHOR-Train-7190.scene_instance.json", + "./9/ProcTHOR-Train-7198.scene_instance.json", + "./9/ProcTHOR-Train-7566.scene_instance.json", + "./9/ProcTHOR-Train-7135.scene_instance.json", + "./9/ProcTHOR-Train-7966.scene_instance.json", + "./9/ProcTHOR-Train-7542.scene_instance.json", + "./9/ProcTHOR-Train-7923.scene_instance.json", + "./9/ProcTHOR-Train-7245.scene_instance.json", + "./9/ProcTHOR-Train-7366.scene_instance.json", + "./9/ProcTHOR-Train-7233.scene_instance.json", + "./9/ProcTHOR-Train-7105.scene_instance.json", + "./9/ProcTHOR-Train-7955.scene_instance.json", + "./9/ProcTHOR-Train-7364.scene_instance.json", + "./9/ProcTHOR-Train-7305.scene_instance.json", + "./9/ProcTHOR-Train-7926.scene_instance.json", + "./9/ProcTHOR-Train-7779.scene_instance.json", + "./9/ProcTHOR-Train-7028.scene_instance.json", + "./9/ProcTHOR-Train-7035.scene_instance.json", + "./9/ProcTHOR-Train-7093.scene_instance.json", + "./9/ProcTHOR-Train-7285.scene_instance.json", + "./9/ProcTHOR-Train-7100.scene_instance.json", + "./9/ProcTHOR-Train-7078.scene_instance.json", + "./9/ProcTHOR-Train-7549.scene_instance.json", + "./9/ProcTHOR-Train-7018.scene_instance.json", + "./9/ProcTHOR-Train-7504.scene_instance.json", + "./9/ProcTHOR-Train-7669.scene_instance.json", + "./9/ProcTHOR-Train-7533.scene_instance.json", + "./9/ProcTHOR-Train-7320.scene_instance.json", + "./9/ProcTHOR-Train-7297.scene_instance.json", + "./9/ProcTHOR-Train-7684.scene_instance.json", + "./9/ProcTHOR-Train-7354.scene_instance.json", + "./9/ProcTHOR-Train-7223.scene_instance.json", + "./9/ProcTHOR-Train-7546.scene_instance.json", + "./9/ProcTHOR-Train-7199.scene_instance.json", + "./9/ProcTHOR-Train-7340.scene_instance.json", + "./9/ProcTHOR-Train-7679.scene_instance.json", + "./9/ProcTHOR-Train-7529.scene_instance.json", + "./9/ProcTHOR-Train-7302.scene_instance.json", + "./9/ProcTHOR-Train-7682.scene_instance.json", + "./9/ProcTHOR-Train-7538.scene_instance.json", + "./9/ProcTHOR-Train-7668.scene_instance.json", + "./9/ProcTHOR-Train-7998.scene_instance.json", + "./9/ProcTHOR-Train-7220.scene_instance.json", + "./9/ProcTHOR-Train-7994.scene_instance.json", + "./9/ProcTHOR-Train-7930.scene_instance.json", + "./9/ProcTHOR-Train-7864.scene_instance.json", + "./9/ProcTHOR-Train-7470.scene_instance.json", + "./9/ProcTHOR-Train-7468.scene_instance.json", + "./9/ProcTHOR-Train-7950.scene_instance.json", + "./9/ProcTHOR-Train-7114.scene_instance.json", + "./9/ProcTHOR-Train-7156.scene_instance.json", + "./9/ProcTHOR-Train-7949.scene_instance.json", + "./9/ProcTHOR-Train-7133.scene_instance.json", + "./9/ProcTHOR-Train-7498.scene_instance.json", + "./9/ProcTHOR-Train-7773.scene_instance.json", + "./9/ProcTHOR-Train-7775.scene_instance.json", + "./9/ProcTHOR-Train-7539.scene_instance.json", + "./9/ProcTHOR-Train-7073.scene_instance.json", + "./9/ProcTHOR-Train-7784.scene_instance.json", + "./9/ProcTHOR-Train-7402.scene_instance.json", + "./9/ProcTHOR-Train-7309.scene_instance.json", + "./9/ProcTHOR-Train-7799.scene_instance.json", + "./9/ProcTHOR-Train-7007.scene_instance.json", + "./9/ProcTHOR-Train-7013.scene_instance.json", + "./9/ProcTHOR-Train-7804.scene_instance.json", + "./9/ProcTHOR-Train-7520.scene_instance.json", + "./9/ProcTHOR-Train-7169.scene_instance.json", + "./9/ProcTHOR-Train-7625.scene_instance.json", + "./9/ProcTHOR-Train-7123.scene_instance.json", + "./9/ProcTHOR-Train-7275.scene_instance.json", + "./9/ProcTHOR-Train-7253.scene_instance.json", + "./9/ProcTHOR-Train-7209.scene_instance.json", + "./9/ProcTHOR-Train-7258.scene_instance.json", + "./9/ProcTHOR-Train-7085.scene_instance.json", + "./9/ProcTHOR-Train-7601.scene_instance.json", + "./9/ProcTHOR-Train-7293.scene_instance.json", + "./9/ProcTHOR-Train-7723.scene_instance.json", + "./9/ProcTHOR-Train-7230.scene_instance.json", + "./9/ProcTHOR-Train-7863.scene_instance.json", + "./9/ProcTHOR-Train-7555.scene_instance.json", + "./9/ProcTHOR-Train-7681.scene_instance.json", + "./9/ProcTHOR-Train-7637.scene_instance.json", + "./9/ProcTHOR-Train-7025.scene_instance.json", + "./9/ProcTHOR-Train-7910.scene_instance.json", + "./9/ProcTHOR-Train-7644.scene_instance.json", + "./9/ProcTHOR-Train-7717.scene_instance.json", + "./9/ProcTHOR-Train-7977.scene_instance.json", + "./9/ProcTHOR-Train-7270.scene_instance.json", + "./9/ProcTHOR-Train-7336.scene_instance.json", + "./9/ProcTHOR-Train-7365.scene_instance.json", + "./9/ProcTHOR-Train-7945.scene_instance.json", + "./9/ProcTHOR-Train-7967.scene_instance.json", + "./9/ProcTHOR-Train-7201.scene_instance.json", + "./9/ProcTHOR-Train-7827.scene_instance.json", + "./9/ProcTHOR-Train-7602.scene_instance.json", + "./9/ProcTHOR-Train-7108.scene_instance.json", + "./9/ProcTHOR-Train-7918.scene_instance.json", + "./9/ProcTHOR-Train-7005.scene_instance.json", + "./9/ProcTHOR-Train-7063.scene_instance.json", + "./9/ProcTHOR-Train-7537.scene_instance.json", + "./9/ProcTHOR-Train-7911.scene_instance.json", + "./9/ProcTHOR-Train-7396.scene_instance.json", + "./9/ProcTHOR-Train-7862.scene_instance.json", + "./9/ProcTHOR-Train-7964.scene_instance.json", + "./9/ProcTHOR-Train-7433.scene_instance.json", + "./9/ProcTHOR-Train-7866.scene_instance.json", + "./9/ProcTHOR-Train-7410.scene_instance.json", + "./9/ProcTHOR-Train-7728.scene_instance.json", + "./9/ProcTHOR-Train-7701.scene_instance.json", + "./9/ProcTHOR-Train-7465.scene_instance.json", + "./9/ProcTHOR-Train-7012.scene_instance.json", + "./9/ProcTHOR-Train-7237.scene_instance.json", + "./9/ProcTHOR-Train-7744.scene_instance.json", + "./9/ProcTHOR-Train-7333.scene_instance.json", + "./9/ProcTHOR-Train-7360.scene_instance.json", + "./9/ProcTHOR-Train-7057.scene_instance.json", + "./9/ProcTHOR-Train-7284.scene_instance.json", + "./9/ProcTHOR-Train-7819.scene_instance.json", + "./9/ProcTHOR-Train-7593.scene_instance.json", + "./9/ProcTHOR-Train-7591.scene_instance.json", + "./9/ProcTHOR-Train-7449.scene_instance.json", + "./9/ProcTHOR-Train-7693.scene_instance.json", + "./9/ProcTHOR-Train-7099.scene_instance.json", + "./9/ProcTHOR-Train-7436.scene_instance.json", + "./9/ProcTHOR-Train-7497.scene_instance.json", + "./9/ProcTHOR-Train-7663.scene_instance.json", + "./9/ProcTHOR-Train-7765.scene_instance.json", + "./9/ProcTHOR-Train-7034.scene_instance.json", + "./9/ProcTHOR-Train-7798.scene_instance.json", + "./9/ProcTHOR-Train-7940.scene_instance.json", + "./9/ProcTHOR-Train-7049.scene_instance.json", + "./9/ProcTHOR-Train-7838.scene_instance.json", + "./9/ProcTHOR-Train-7443.scene_instance.json", + "./9/ProcTHOR-Train-7187.scene_instance.json", + "./9/ProcTHOR-Train-7457.scene_instance.json", + "./9/ProcTHOR-Train-7550.scene_instance.json", + "./9/ProcTHOR-Train-7664.scene_instance.json", + "./9/ProcTHOR-Train-7221.scene_instance.json", + "./9/ProcTHOR-Train-7558.scene_instance.json", + "./9/ProcTHOR-Train-7692.scene_instance.json", + "./9/ProcTHOR-Train-7390.scene_instance.json", + "./9/ProcTHOR-Train-7572.scene_instance.json", + "./9/ProcTHOR-Train-7427.scene_instance.json", + "./9/ProcTHOR-Train-7822.scene_instance.json", + "./9/ProcTHOR-Train-7993.scene_instance.json", + "./9/ProcTHOR-Train-7478.scene_instance.json", + "./9/ProcTHOR-Train-7954.scene_instance.json", + "./9/ProcTHOR-Train-7557.scene_instance.json", + "./9/ProcTHOR-Train-7552.scene_instance.json", + "./9/ProcTHOR-Train-7826.scene_instance.json", + "./9/ProcTHOR-Train-7595.scene_instance.json", + "./9/ProcTHOR-Train-7675.scene_instance.json", + "./9/ProcTHOR-Train-7413.scene_instance.json", + "./9/ProcTHOR-Train-7027.scene_instance.json", + "./9/ProcTHOR-Train-7908.scene_instance.json", + "./9/ProcTHOR-Train-7915.scene_instance.json", + "./9/ProcTHOR-Train-7016.scene_instance.json", + "./9/ProcTHOR-Train-7367.scene_instance.json", + "./9/ProcTHOR-Train-7997.scene_instance.json", + "./9/ProcTHOR-Train-7363.scene_instance.json", + "./9/ProcTHOR-Train-7243.scene_instance.json", + "./9/ProcTHOR-Train-7528.scene_instance.json", + "./9/ProcTHOR-Train-7778.scene_instance.json", + "./9/ProcTHOR-Train-7466.scene_instance.json", + "./9/ProcTHOR-Train-7134.scene_instance.json", + "./9/ProcTHOR-Train-7484.scene_instance.json", + "./9/ProcTHOR-Train-7051.scene_instance.json", + "./9/ProcTHOR-Train-7770.scene_instance.json", + "./9/ProcTHOR-Train-7104.scene_instance.json", + "./9/ProcTHOR-Train-7541.scene_instance.json", + "./9/ProcTHOR-Train-7753.scene_instance.json", + "./9/ProcTHOR-Train-7331.scene_instance.json", + "./9/ProcTHOR-Train-7881.scene_instance.json", + "./9/ProcTHOR-Train-7755.scene_instance.json", + "./9/ProcTHOR-Train-7978.scene_instance.json", + "./9/ProcTHOR-Train-7599.scene_instance.json", + "./9/ProcTHOR-Train-7165.scene_instance.json", + "./9/ProcTHOR-Train-7015.scene_instance.json", + "./9/ProcTHOR-Train-7635.scene_instance.json", + "./9/ProcTHOR-Train-7594.scene_instance.json", + "./9/ProcTHOR-Train-7891.scene_instance.json", + "./9/ProcTHOR-Train-7563.scene_instance.json", + "./9/ProcTHOR-Train-7853.scene_instance.json", + "./9/ProcTHOR-Train-7958.scene_instance.json", + "./9/ProcTHOR-Train-7235.scene_instance.json", + "./9/ProcTHOR-Train-7942.scene_instance.json", + "./9/ProcTHOR-Train-7074.scene_instance.json", + "./9/ProcTHOR-Train-7727.scene_instance.json", + "./9/ProcTHOR-Train-7589.scene_instance.json", + "./9/ProcTHOR-Train-7319.scene_instance.json", + "./9/ProcTHOR-Train-7329.scene_instance.json", + "./9/ProcTHOR-Train-7569.scene_instance.json", + "./9/ProcTHOR-Train-7118.scene_instance.json", + "./9/ProcTHOR-Train-7502.scene_instance.json", + "./9/ProcTHOR-Train-7982.scene_instance.json", + "./9/ProcTHOR-Train-7264.scene_instance.json", + "./9/ProcTHOR-Train-7458.scene_instance.json", + "./9/ProcTHOR-Train-7695.scene_instance.json", + "./9/ProcTHOR-Train-7638.scene_instance.json", + "./9/ProcTHOR-Train-7992.scene_instance.json", + "./9/ProcTHOR-Train-7479.scene_instance.json", + "./9/ProcTHOR-Train-7522.scene_instance.json", + "./9/ProcTHOR-Train-7393.scene_instance.json", + "./9/ProcTHOR-Train-7155.scene_instance.json", + "./9/ProcTHOR-Train-7214.scene_instance.json", + "./9/ProcTHOR-Train-7061.scene_instance.json", + "./9/ProcTHOR-Train-7117.scene_instance.json", + "./9/ProcTHOR-Train-7225.scene_instance.json", + "./9/ProcTHOR-Train-7545.scene_instance.json", + "./9/ProcTHOR-Train-7194.scene_instance.json", + "./9/ProcTHOR-Train-7608.scene_instance.json", + "./9/ProcTHOR-Train-7437.scene_instance.json", + "./9/ProcTHOR-Train-7872.scene_instance.json", + "./9/ProcTHOR-Train-7252.scene_instance.json", + "./9/ProcTHOR-Train-7667.scene_instance.json", + "./9/ProcTHOR-Train-7856.scene_instance.json", + "./9/ProcTHOR-Train-7475.scene_instance.json", + "./9/ProcTHOR-Train-7477.scene_instance.json", + "./9/ProcTHOR-Train-7463.scene_instance.json", + "./9/ProcTHOR-Train-7760.scene_instance.json", + "./9/ProcTHOR-Train-7414.scene_instance.json", + "./9/ProcTHOR-Train-7963.scene_instance.json", + "./9/ProcTHOR-Train-7535.scene_instance.json", + "./9/ProcTHOR-Train-7833.scene_instance.json", + "./9/ProcTHOR-Train-7874.scene_instance.json", + "./9/ProcTHOR-Train-7186.scene_instance.json", + "./9/ProcTHOR-Train-7970.scene_instance.json", + "./9/ProcTHOR-Train-7153.scene_instance.json", + "./9/ProcTHOR-Train-7069.scene_instance.json", + "./9/ProcTHOR-Train-7884.scene_instance.json", + "./9/ProcTHOR-Train-7295.scene_instance.json", + "./9/ProcTHOR-Train-7430.scene_instance.json", + "./9/ProcTHOR-Train-7162.scene_instance.json", + "./9/ProcTHOR-Train-7488.scene_instance.json", + "./9/ProcTHOR-Train-7083.scene_instance.json", + "./9/ProcTHOR-Train-7924.scene_instance.json", + "./9/ProcTHOR-Train-7627.scene_instance.json", + "./9/ProcTHOR-Train-7922.scene_instance.json", + "./9/ProcTHOR-Train-7271.scene_instance.json", + "./9/ProcTHOR-Train-7343.scene_instance.json", + "./9/ProcTHOR-Train-7077.scene_instance.json", + "./9/ProcTHOR-Train-7624.scene_instance.json", + "./9/ProcTHOR-Train-7420.scene_instance.json", + "./9/ProcTHOR-Train-7711.scene_instance.json", + "./9/ProcTHOR-Train-7406.scene_instance.json", + "./9/ProcTHOR-Train-7250.scene_instance.json", + "./9/ProcTHOR-Train-7382.scene_instance.json", + "./9/ProcTHOR-Train-7103.scene_instance.json", + "./9/ProcTHOR-Train-7014.scene_instance.json", + "./9/ProcTHOR-Train-7269.scene_instance.json", + "./9/ProcTHOR-Train-7632.scene_instance.json", + "./9/ProcTHOR-Train-7244.scene_instance.json", + "./9/ProcTHOR-Train-7267.scene_instance.json", + "./9/ProcTHOR-Train-7087.scene_instance.json", + "./9/ProcTHOR-Train-7586.scene_instance.json", + "./9/ProcTHOR-Train-7326.scene_instance.json", + "./9/ProcTHOR-Train-7991.scene_instance.json", + "./9/ProcTHOR-Train-7786.scene_instance.json", + "./9/ProcTHOR-Train-7948.scene_instance.json", + "./9/ProcTHOR-Train-7767.scene_instance.json", + "./9/ProcTHOR-Train-7089.scene_instance.json", + "./9/ProcTHOR-Train-7514.scene_instance.json", + "./9/ProcTHOR-Train-7179.scene_instance.json", + "./9/ProcTHOR-Train-7888.scene_instance.json", + "./9/ProcTHOR-Train-7124.scene_instance.json", + "./9/ProcTHOR-Train-7330.scene_instance.json", + "./9/ProcTHOR-Train-7745.scene_instance.json", + "./9/ProcTHOR-Train-7769.scene_instance.json", + "./9/ProcTHOR-Train-7129.scene_instance.json", + "./9/ProcTHOR-Train-7242.scene_instance.json", + "./9/ProcTHOR-Train-7976.scene_instance.json", + "./9/ProcTHOR-Train-7026.scene_instance.json", + "./9/ProcTHOR-Train-7724.scene_instance.json", + "./9/ProcTHOR-Train-7429.scene_instance.json", + "./9/ProcTHOR-Train-7721.scene_instance.json", + "./9/ProcTHOR-Train-7283.scene_instance.json", + "./9/ProcTHOR-Train-7066.scene_instance.json", + "./9/ProcTHOR-Train-7338.scene_instance.json", + "./9/ProcTHOR-Train-7795.scene_instance.json", + "./9/ProcTHOR-Train-7147.scene_instance.json", + "./9/ProcTHOR-Train-7824.scene_instance.json", + "./9/ProcTHOR-Train-7510.scene_instance.json", + "./9/ProcTHOR-Train-7431.scene_instance.json", + "./9/ProcTHOR-Train-7119.scene_instance.json", + "./9/ProcTHOR-Train-7747.scene_instance.json", + "./9/ProcTHOR-Train-7713.scene_instance.json", + "./9/ProcTHOR-Train-7564.scene_instance.json", + "./9/ProcTHOR-Train-7526.scene_instance.json", + "./9/ProcTHOR-Train-7995.scene_instance.json", + "./9/ProcTHOR-Train-7583.scene_instance.json", + "./9/ProcTHOR-Train-7709.scene_instance.json", + "./9/ProcTHOR-Train-7615.scene_instance.json", + "./9/ProcTHOR-Train-7649.scene_instance.json", + "./9/ProcTHOR-Train-7800.scene_instance.json", + "./9/ProcTHOR-Train-7859.scene_instance.json", + "./9/ProcTHOR-Train-7648.scene_instance.json", + "./9/ProcTHOR-Train-7732.scene_instance.json", + "./9/ProcTHOR-Train-7217.scene_instance.json", + "./9/ProcTHOR-Train-7044.scene_instance.json", + "./9/ProcTHOR-Train-7265.scene_instance.json", + "./9/ProcTHOR-Train-7739.scene_instance.json", + "./9/ProcTHOR-Train-7495.scene_instance.json", + "./9/ProcTHOR-Train-7379.scene_instance.json", + "./9/ProcTHOR-Train-7180.scene_instance.json", + "./9/ProcTHOR-Train-7473.scene_instance.json", + "./9/ProcTHOR-Train-7324.scene_instance.json", + "./9/ProcTHOR-Train-7740.scene_instance.json", + "./9/ProcTHOR-Train-7670.scene_instance.json", + "./9/ProcTHOR-Train-7808.scene_instance.json", + "./9/ProcTHOR-Train-7722.scene_instance.json", + "./9/ProcTHOR-Train-7189.scene_instance.json", + "./9/ProcTHOR-Train-7793.scene_instance.json", + "./9/ProcTHOR-Train-7843.scene_instance.json", + "./9/ProcTHOR-Train-7471.scene_instance.json", + "./9/ProcTHOR-Train-7756.scene_instance.json", + "./9/ProcTHOR-Train-7404.scene_instance.json", + "./9/ProcTHOR-Train-7746.scene_instance.json", + "./9/ProcTHOR-Train-7148.scene_instance.json", + "./9/ProcTHOR-Train-7780.scene_instance.json", + "./9/ProcTHOR-Train-7534.scene_instance.json", + "./9/ProcTHOR-Train-7274.scene_instance.json", + "./9/ProcTHOR-Train-7845.scene_instance.json", + "./9/ProcTHOR-Train-7116.scene_instance.json", + "./9/ProcTHOR-Train-7037.scene_instance.json", + "./9/ProcTHOR-Train-7098.scene_instance.json", + "./9/ProcTHOR-Train-7425.scene_instance.json", + "./9/ProcTHOR-Train-7262.scene_instance.json", + "./9/ProcTHOR-Train-7474.scene_instance.json", + "./9/ProcTHOR-Train-7453.scene_instance.json", + "./9/ProcTHOR-Train-7332.scene_instance.json", + "./9/ProcTHOR-Train-7313.scene_instance.json", + "./9/ProcTHOR-Train-7544.scene_instance.json", + "./9/ProcTHOR-Train-7438.scene_instance.json", + "./9/ProcTHOR-Train-7310.scene_instance.json", + "./9/ProcTHOR-Train-7962.scene_instance.json", + "./9/ProcTHOR-Train-7011.scene_instance.json", + "./9/ProcTHOR-Train-7726.scene_instance.json", + "./9/ProcTHOR-Train-7956.scene_instance.json", + "./9/ProcTHOR-Train-7515.scene_instance.json", + "./9/ProcTHOR-Train-7380.scene_instance.json", + "./9/ProcTHOR-Train-7543.scene_instance.json", + "./9/ProcTHOR-Train-7628.scene_instance.json", + "./9/ProcTHOR-Train-7943.scene_instance.json", + "./9/ProcTHOR-Train-7830.scene_instance.json", + "./9/ProcTHOR-Train-7384.scene_instance.json", + "./9/ProcTHOR-Train-7847.scene_instance.json", + "./9/ProcTHOR-Train-7171.scene_instance.json", + "./9/ProcTHOR-Train-7946.scene_instance.json", + "./9/ProcTHOR-Train-7048.scene_instance.json", + "./9/ProcTHOR-Train-7731.scene_instance.json", + "./9/ProcTHOR-Train-7715.scene_instance.json", + "./9/ProcTHOR-Train-7776.scene_instance.json", + "./9/ProcTHOR-Train-7836.scene_instance.json", + "./9/ProcTHOR-Train-7110.scene_instance.json", + "./9/ProcTHOR-Train-7486.scene_instance.json", + "./9/ProcTHOR-Train-7009.scene_instance.json", + "./9/ProcTHOR-Train-7075.scene_instance.json", + "./9/ProcTHOR-Train-7476.scene_instance.json", + "./9/ProcTHOR-Train-7266.scene_instance.json", + "./9/ProcTHOR-Train-7553.scene_instance.json", + "./9/ProcTHOR-Train-7714.scene_instance.json", + "./9/ProcTHOR-Train-7886.scene_instance.json", + "./9/ProcTHOR-Train-7749.scene_instance.json", + "./9/ProcTHOR-Train-7817.scene_instance.json", + "./9/ProcTHOR-Train-7646.scene_instance.json", + "./9/ProcTHOR-Train-7076.scene_instance.json", + "./9/ProcTHOR-Train-7766.scene_instance.json", + "./9/ProcTHOR-Train-7959.scene_instance.json", + "./9/ProcTHOR-Train-7704.scene_instance.json", + "./9/ProcTHOR-Train-7511.scene_instance.json", + "./9/ProcTHOR-Train-7144.scene_instance.json", + "./9/ProcTHOR-Train-7750.scene_instance.json", + "./9/ProcTHOR-Train-7348.scene_instance.json", + "./9/ProcTHOR-Train-7464.scene_instance.json", + "./9/ProcTHOR-Train-7388.scene_instance.json", + "./9/ProcTHOR-Train-7167.scene_instance.json", + "./9/ProcTHOR-Train-7673.scene_instance.json", + "./9/ProcTHOR-Train-7934.scene_instance.json", + "./9/ProcTHOR-Train-7802.scene_instance.json", + "./9/ProcTHOR-Train-7925.scene_instance.json", + "./9/ProcTHOR-Train-7050.scene_instance.json", + "./9/ProcTHOR-Train-7207.scene_instance.json", + "./9/ProcTHOR-Train-7844.scene_instance.json", + "./9/ProcTHOR-Train-7811.scene_instance.json", + "./9/ProcTHOR-Train-7403.scene_instance.json", + "./9/ProcTHOR-Train-7459.scene_instance.json", + "./9/ProcTHOR-Train-7574.scene_instance.json", + "./9/ProcTHOR-Train-7508.scene_instance.json", + "./9/ProcTHOR-Train-7777.scene_instance.json", + "./9/ProcTHOR-Train-7858.scene_instance.json", + "./9/ProcTHOR-Train-7095.scene_instance.json", + "./9/ProcTHOR-Train-7185.scene_instance.json", + "./9/ProcTHOR-Train-7341.scene_instance.json", + "./9/ProcTHOR-Train-7152.scene_instance.json", + "./9/ProcTHOR-Train-7240.scene_instance.json", + "./9/ProcTHOR-Train-7865.scene_instance.json", + "./9/ProcTHOR-Train-7636.scene_instance.json", + "./9/ProcTHOR-Train-7657.scene_instance.json", + "./9/ProcTHOR-Train-7070.scene_instance.json", + "./9/ProcTHOR-Train-7797.scene_instance.json", + "./9/ProcTHOR-Train-7278.scene_instance.json", + "./9/ProcTHOR-Train-7084.scene_instance.json", + "./9/ProcTHOR-Train-7038.scene_instance.json", + "./9/ProcTHOR-Train-7120.scene_instance.json", + "./9/ProcTHOR-Train-7462.scene_instance.json", + "./9/ProcTHOR-Train-7674.scene_instance.json", + "./9/ProcTHOR-Train-7023.scene_instance.json", + "./9/ProcTHOR-Train-7697.scene_instance.json", + "./9/ProcTHOR-Train-7434.scene_instance.json", + "./9/ProcTHOR-Train-7785.scene_instance.json", + "./9/ProcTHOR-Train-7397.scene_instance.json", + "./9/ProcTHOR-Train-7136.scene_instance.json", + "./9/ProcTHOR-Train-7885.scene_instance.json", + "./9/ProcTHOR-Train-7218.scene_instance.json", + "./9/ProcTHOR-Train-7633.scene_instance.json", + "./9/ProcTHOR-Train-7202.scene_instance.json", + "./9/ProcTHOR-Train-7694.scene_instance.json", + "./9/ProcTHOR-Train-7653.scene_instance.json", + "./9/ProcTHOR-Train-7988.scene_instance.json", + "./9/ProcTHOR-Train-7642.scene_instance.json", + "./9/ProcTHOR-Train-7718.scene_instance.json", + "./9/ProcTHOR-Train-7647.scene_instance.json", + "./9/ProcTHOR-Train-7400.scene_instance.json", + "./9/ProcTHOR-Train-7842.scene_instance.json", + "./9/ProcTHOR-Train-7273.scene_instance.json", + "./9/ProcTHOR-Train-7352.scene_instance.json", + "./9/ProcTHOR-Train-7849.scene_instance.json", + "./9/ProcTHOR-Train-7296.scene_instance.json", + "./9/ProcTHOR-Train-7239.scene_instance.json", + "./9/ProcTHOR-Train-7327.scene_instance.json", + "./9/ProcTHOR-Train-7554.scene_instance.json", + "./9/ProcTHOR-Train-7126.scene_instance.json", + "./9/ProcTHOR-Train-7848.scene_instance.json", + "./9/ProcTHOR-Train-7573.scene_instance.json", + "./9/ProcTHOR-Train-7447.scene_instance.json", + "./9/ProcTHOR-Train-7053.scene_instance.json", + "./9/ProcTHOR-Train-7912.scene_instance.json", + "./9/ProcTHOR-Train-7111.scene_instance.json", + "./9/ProcTHOR-Train-7399.scene_instance.json", + "./9/ProcTHOR-Train-7450.scene_instance.json", + "./9/ProcTHOR-Train-7317.scene_instance.json", + "./9/ProcTHOR-Train-7961.scene_instance.json", + "./9/ProcTHOR-Train-7377.scene_instance.json", + "./9/ProcTHOR-Train-7656.scene_instance.json", + "./9/ProcTHOR-Train-7139.scene_instance.json", + "./9/ProcTHOR-Train-7499.scene_instance.json", + "./9/ProcTHOR-Train-7687.scene_instance.json", + "./9/ProcTHOR-Train-7509.scene_instance.json", + "./9/ProcTHOR-Train-7349.scene_instance.json", + "./9/ProcTHOR-Train-7276.scene_instance.json", + "./9/ProcTHOR-Train-7620.scene_instance.json", + "./9/ProcTHOR-Train-7607.scene_instance.json", + "./9/ProcTHOR-Train-7106.scene_instance.json", + "./9/ProcTHOR-Train-7141.scene_instance.json", + "./9/ProcTHOR-Train-7255.scene_instance.json", + "./9/ProcTHOR-Train-7841.scene_instance.json", + "./9/ProcTHOR-Train-7933.scene_instance.json", + "./9/ProcTHOR-Train-7944.scene_instance.json", + "./9/ProcTHOR-Train-7631.scene_instance.json", + "./9/ProcTHOR-Train-7889.scene_instance.json", + "./9/ProcTHOR-Train-7807.scene_instance.json", + "./9/ProcTHOR-Train-7757.scene_instance.json", + "./9/ProcTHOR-Train-7115.scene_instance.json", + "./9/ProcTHOR-Train-7630.scene_instance.json", + "./9/ProcTHOR-Train-7971.scene_instance.json", + "./9/ProcTHOR-Train-7208.scene_instance.json", + "./9/ProcTHOR-Train-7122.scene_instance.json", + "./9/ProcTHOR-Train-7875.scene_instance.json", + "./9/ProcTHOR-Train-7917.scene_instance.json", + "./9/ProcTHOR-Train-7112.scene_instance.json", + "./9/ProcTHOR-Train-7290.scene_instance.json", + "./9/ProcTHOR-Train-7699.scene_instance.json", + "./9/ProcTHOR-Train-7729.scene_instance.json", + "./9/ProcTHOR-Train-7901.scene_instance.json", + "./9/ProcTHOR-Train-7507.scene_instance.json", + "./9/ProcTHOR-Train-7986.scene_instance.json", + "./9/ProcTHOR-Train-7616.scene_instance.json", + "./9/ProcTHOR-Train-7570.scene_instance.json", + "./9/ProcTHOR-Train-7584.scene_instance.json", + "./9/ProcTHOR-Train-7683.scene_instance.json", + "./9/ProcTHOR-Train-7101.scene_instance.json", + "./9/ProcTHOR-Train-7561.scene_instance.json", + "./9/ProcTHOR-Train-7260.scene_instance.json", + "./9/ProcTHOR-Train-7251.scene_instance.json", + "./9/ProcTHOR-Train-7407.scene_instance.json", + "./9/ProcTHOR-Train-7512.scene_instance.json", + "./9/ProcTHOR-Train-7231.scene_instance.json", + "./9/ProcTHOR-Train-7489.scene_instance.json", + "./9/ProcTHOR-Train-7176.scene_instance.json", + "./9/ProcTHOR-Train-7292.scene_instance.json", + "./9/ProcTHOR-Train-7505.scene_instance.json", + "./9/ProcTHOR-Train-7734.scene_instance.json", + "./9/ProcTHOR-Train-7787.scene_instance.json", + "./9/ProcTHOR-Train-7983.scene_instance.json", + "./9/ProcTHOR-Train-7598.scene_instance.json", + "./9/ProcTHOR-Train-7423.scene_instance.json", + "./9/ProcTHOR-Train-7121.scene_instance.json", + "./9/ProcTHOR-Train-7460.scene_instance.json", + "./9/ProcTHOR-Train-7748.scene_instance.json", + "./9/ProcTHOR-Train-7456.scene_instance.json", + "./9/ProcTHOR-Train-7467.scene_instance.json", + "./9/ProcTHOR-Train-7188.scene_instance.json", + "./9/ProcTHOR-Train-7142.scene_instance.json", + "./9/ProcTHOR-Train-7932.scene_instance.json", + "./9/ProcTHOR-Train-7312.scene_instance.json", + "./9/ProcTHOR-Train-7751.scene_instance.json", + "./9/ProcTHOR-Train-7102.scene_instance.json", + "./9/ProcTHOR-Train-7355.scene_instance.json", + "./9/ProcTHOR-Train-7772.scene_instance.json", + "./9/ProcTHOR-Train-7097.scene_instance.json", + "./9/ProcTHOR-Train-7191.scene_instance.json", + "./9/ProcTHOR-Train-7895.scene_instance.json", + "./9/ProcTHOR-Train-7634.scene_instance.json", + "./9/ProcTHOR-Train-7576.scene_instance.json", + "./9/ProcTHOR-Train-7345.scene_instance.json", + "./9/ProcTHOR-Train-7236.scene_instance.json", + "./9/ProcTHOR-Train-7132.scene_instance.json", + "./9/ProcTHOR-Train-7754.scene_instance.json", + "./9/ProcTHOR-Train-7575.scene_instance.json", + "./9/ProcTHOR-Train-7145.scene_instance.json", + "./9/ProcTHOR-Train-7816.scene_instance.json", + "./9/ProcTHOR-Train-7587.scene_instance.json", + "./9/ProcTHOR-Train-7247.scene_instance.json", + "./9/ProcTHOR-Train-7469.scene_instance.json", + "./9/ProcTHOR-Train-7472.scene_instance.json", + "./9/ProcTHOR-Train-7125.scene_instance.json", + "./9/ProcTHOR-Train-7065.scene_instance.json", + "./9/ProcTHOR-Train-7298.scene_instance.json", + "./9/ProcTHOR-Train-7590.scene_instance.json", + "./9/ProcTHOR-Train-7703.scene_instance.json", + "./9/ProcTHOR-Train-7094.scene_instance.json", + "./9/ProcTHOR-Train-7315.scene_instance.json", + "./9/ProcTHOR-Train-7730.scene_instance.json", + "./9/ProcTHOR-Train-7868.scene_instance.json", + "./9/ProcTHOR-Train-7560.scene_instance.json", + "./9/ProcTHOR-Train-7987.scene_instance.json", + "./9/ProcTHOR-Train-7154.scene_instance.json", + "./9/ProcTHOR-Train-7938.scene_instance.json", + "./9/ProcTHOR-Train-7168.scene_instance.json", + "./9/ProcTHOR-Train-7758.scene_instance.json", + "./9/ProcTHOR-Train-7046.scene_instance.json", + "./9/ProcTHOR-Train-7989.scene_instance.json", + "./9/ProcTHOR-Train-7081.scene_instance.json", + "./9/ProcTHOR-Train-7405.scene_instance.json", + "./9/ProcTHOR-Train-7921.scene_instance.json", + "./9/ProcTHOR-Train-7042.scene_instance.json", + "./9/ProcTHOR-Train-7287.scene_instance.json", + "./9/ProcTHOR-Train-7369.scene_instance.json", + "./9/ProcTHOR-Train-7519.scene_instance.json", + "./9/ProcTHOR-Train-7033.scene_instance.json", + "./9/ProcTHOR-Train-7820.scene_instance.json", + "./9/ProcTHOR-Train-7639.scene_instance.json", + "./9/ProcTHOR-Train-7131.scene_instance.json", + "./9/ProcTHOR-Train-7496.scene_instance.json", + "./9/ProcTHOR-Train-7387.scene_instance.json", + "./9/ProcTHOR-Train-7619.scene_instance.json", + "./9/ProcTHOR-Train-7480.scene_instance.json", + "./9/ProcTHOR-Train-7929.scene_instance.json", + "./9/ProcTHOR-Train-7398.scene_instance.json", + "./9/ProcTHOR-Train-7289.scene_instance.json", + "./9/ProcTHOR-Train-7712.scene_instance.json", + "./9/ProcTHOR-Train-7540.scene_instance.json", + "./9/ProcTHOR-Train-7193.scene_instance.json", + "./9/ProcTHOR-Train-7316.scene_instance.json", + "./9/ProcTHOR-Train-7990.scene_instance.json", + "./9/ProcTHOR-Train-7600.scene_instance.json", + "./9/ProcTHOR-Train-7665.scene_instance.json", + "./9/ProcTHOR-Train-7837.scene_instance.json", + "./9/ProcTHOR-Train-7200.scene_instance.json", + "./9/ProcTHOR-Train-7211.scene_instance.json", + "./9/ProcTHOR-Train-7043.scene_instance.json", + "./9/ProcTHOR-Train-7975.scene_instance.json", + "./9/ProcTHOR-Train-7067.scene_instance.json", + "./9/ProcTHOR-Train-7691.scene_instance.json", + "./9/ProcTHOR-Train-7939.scene_instance.json", + "./9/ProcTHOR-Train-7219.scene_instance.json", + "./9/ProcTHOR-Train-7372.scene_instance.json", + "./9/ProcTHOR-Train-7762.scene_instance.json", + "./9/ProcTHOR-Train-7041.scene_instance.json", + "./9/ProcTHOR-Train-7421.scene_instance.json", + "./9/ProcTHOR-Train-7810.scene_instance.json", + "./9/ProcTHOR-Train-7166.scene_instance.json", + "./9/ProcTHOR-Train-7707.scene_instance.json", + "./9/ProcTHOR-Train-7428.scene_instance.json", + "./9/ProcTHOR-Train-7308.scene_instance.json", + "./9/ProcTHOR-Train-7877.scene_instance.json", + "./9/ProcTHOR-Train-7999.scene_instance.json", + "./9/ProcTHOR-Train-7880.scene_instance.json", + "./9/ProcTHOR-Train-7216.scene_instance.json", + "./9/ProcTHOR-Train-7419.scene_instance.json", + "./9/ProcTHOR-Train-7335.scene_instance.json", + "./9/ProcTHOR-Train-7150.scene_instance.json", + "./9/ProcTHOR-Train-7585.scene_instance.json", + "./9/ProcTHOR-Train-7610.scene_instance.json", + "./9/ProcTHOR-Train-7985.scene_instance.json", + "./9/ProcTHOR-Train-7368.scene_instance.json", + "./9/ProcTHOR-Train-7898.scene_instance.json", + "./9/ProcTHOR-Train-7375.scene_instance.json", + "./9/ProcTHOR-Train-7391.scene_instance.json", + "./9/ProcTHOR-Train-7376.scene_instance.json", + "./9/ProcTHOR-Train-7128.scene_instance.json", + "./9/ProcTHOR-Train-7916.scene_instance.json", + "./9/ProcTHOR-Train-7839.scene_instance.json", + "./9/ProcTHOR-Train-7980.scene_instance.json", + "./9/ProcTHOR-Train-7951.scene_instance.json", + "./9/ProcTHOR-Train-7263.scene_instance.json", + "./9/ProcTHOR-Train-7761.scene_instance.json", + "./9/ProcTHOR-Train-7272.scene_instance.json", + "./9/ProcTHOR-Train-7720.scene_instance.json", + "./9/ProcTHOR-Train-7568.scene_instance.json", + "./9/ProcTHOR-Train-7254.scene_instance.json", + "./9/ProcTHOR-Train-7524.scene_instance.json", + "./9/ProcTHOR-Train-7614.scene_instance.json", + "./9/ProcTHOR-Train-7256.scene_instance.json", + "./9/ProcTHOR-Train-7170.scene_instance.json", + "./9/ProcTHOR-Train-7222.scene_instance.json", + "./9/ProcTHOR-Train-7432.scene_instance.json", + "./5/ProcTHOR-Train-3033.scene_instance.json", + "./5/ProcTHOR-Train-3048.scene_instance.json", + "./5/ProcTHOR-Train-3734.scene_instance.json", + "./5/ProcTHOR-Train-3105.scene_instance.json", + "./5/ProcTHOR-Train-3592.scene_instance.json", + "./5/ProcTHOR-Train-3192.scene_instance.json", + "./5/ProcTHOR-Train-3633.scene_instance.json", + "./5/ProcTHOR-Train-3983.scene_instance.json", + "./5/ProcTHOR-Train-3361.scene_instance.json", + "./5/ProcTHOR-Train-3834.scene_instance.json", + "./5/ProcTHOR-Train-3039.scene_instance.json", + "./5/ProcTHOR-Train-3090.scene_instance.json", + "./5/ProcTHOR-Train-3691.scene_instance.json", + "./5/ProcTHOR-Train-3141.scene_instance.json", + "./5/ProcTHOR-Train-3230.scene_instance.json", + "./5/ProcTHOR-Train-3699.scene_instance.json", + "./5/ProcTHOR-Train-3767.scene_instance.json", + "./5/ProcTHOR-Train-3085.scene_instance.json", + "./5/ProcTHOR-Train-3235.scene_instance.json", + "./5/ProcTHOR-Train-3620.scene_instance.json", + "./5/ProcTHOR-Train-3822.scene_instance.json", + "./5/ProcTHOR-Train-3140.scene_instance.json", + "./5/ProcTHOR-Train-3787.scene_instance.json", + "./5/ProcTHOR-Train-3255.scene_instance.json", + "./5/ProcTHOR-Train-3953.scene_instance.json", + "./5/ProcTHOR-Train-3847.scene_instance.json", + "./5/ProcTHOR-Train-3789.scene_instance.json", + "./5/ProcTHOR-Train-3873.scene_instance.json", + "./5/ProcTHOR-Train-3560.scene_instance.json", + "./5/ProcTHOR-Train-3113.scene_instance.json", + "./5/ProcTHOR-Train-3784.scene_instance.json", + "./5/ProcTHOR-Train-3660.scene_instance.json", + "./5/ProcTHOR-Train-3247.scene_instance.json", + "./5/ProcTHOR-Train-3475.scene_instance.json", + "./5/ProcTHOR-Train-3210.scene_instance.json", + "./5/ProcTHOR-Train-3384.scene_instance.json", + "./5/ProcTHOR-Train-3999.scene_instance.json", + "./5/ProcTHOR-Train-3261.scene_instance.json", + "./5/ProcTHOR-Train-3740.scene_instance.json", + "./5/ProcTHOR-Train-3516.scene_instance.json", + "./5/ProcTHOR-Train-3435.scene_instance.json", + "./5/ProcTHOR-Train-3590.scene_instance.json", + "./5/ProcTHOR-Train-3538.scene_instance.json", + "./5/ProcTHOR-Train-3051.scene_instance.json", + "./5/ProcTHOR-Train-3246.scene_instance.json", + "./5/ProcTHOR-Train-3738.scene_instance.json", + "./5/ProcTHOR-Train-3714.scene_instance.json", + "./5/ProcTHOR-Train-3539.scene_instance.json", + "./5/ProcTHOR-Train-3344.scene_instance.json", + "./5/ProcTHOR-Train-3732.scene_instance.json", + "./5/ProcTHOR-Train-3149.scene_instance.json", + "./5/ProcTHOR-Train-3558.scene_instance.json", + "./5/ProcTHOR-Train-3687.scene_instance.json", + "./5/ProcTHOR-Train-3131.scene_instance.json", + "./5/ProcTHOR-Train-3436.scene_instance.json", + "./5/ProcTHOR-Train-3936.scene_instance.json", + "./5/ProcTHOR-Train-3610.scene_instance.json", + "./5/ProcTHOR-Train-3310.scene_instance.json", + "./5/ProcTHOR-Train-3444.scene_instance.json", + "./5/ProcTHOR-Train-3901.scene_instance.json", + "./5/ProcTHOR-Train-3584.scene_instance.json", + "./5/ProcTHOR-Train-3201.scene_instance.json", + "./5/ProcTHOR-Train-3121.scene_instance.json", + "./5/ProcTHOR-Train-3028.scene_instance.json", + "./5/ProcTHOR-Train-3678.scene_instance.json", + "./5/ProcTHOR-Train-3302.scene_instance.json", + "./5/ProcTHOR-Train-3677.scene_instance.json", + "./5/ProcTHOR-Train-3618.scene_instance.json", + "./5/ProcTHOR-Train-3893.scene_instance.json", + "./5/ProcTHOR-Train-3708.scene_instance.json", + "./5/ProcTHOR-Train-3616.scene_instance.json", + "./5/ProcTHOR-Train-3237.scene_instance.json", + "./5/ProcTHOR-Train-3904.scene_instance.json", + "./5/ProcTHOR-Train-3315.scene_instance.json", + "./5/ProcTHOR-Train-3156.scene_instance.json", + "./5/ProcTHOR-Train-3720.scene_instance.json", + "./5/ProcTHOR-Train-3611.scene_instance.json", + "./5/ProcTHOR-Train-3056.scene_instance.json", + "./5/ProcTHOR-Train-3157.scene_instance.json", + "./5/ProcTHOR-Train-3049.scene_instance.json", + "./5/ProcTHOR-Train-3364.scene_instance.json", + "./5/ProcTHOR-Train-3397.scene_instance.json", + "./5/ProcTHOR-Train-3074.scene_instance.json", + "./5/ProcTHOR-Train-3392.scene_instance.json", + "./5/ProcTHOR-Train-3434.scene_instance.json", + "./5/ProcTHOR-Train-3510.scene_instance.json", + "./5/ProcTHOR-Train-3991.scene_instance.json", + "./5/ProcTHOR-Train-3644.scene_instance.json", + "./5/ProcTHOR-Train-3101.scene_instance.json", + "./5/ProcTHOR-Train-3413.scene_instance.json", + "./5/ProcTHOR-Train-3494.scene_instance.json", + "./5/ProcTHOR-Train-3772.scene_instance.json", + "./5/ProcTHOR-Train-3273.scene_instance.json", + "./5/ProcTHOR-Train-3902.scene_instance.json", + "./5/ProcTHOR-Train-3428.scene_instance.json", + "./5/ProcTHOR-Train-3053.scene_instance.json", + "./5/ProcTHOR-Train-3963.scene_instance.json", + "./5/ProcTHOR-Train-3985.scene_instance.json", + "./5/ProcTHOR-Train-3011.scene_instance.json", + "./5/ProcTHOR-Train-3889.scene_instance.json", + "./5/ProcTHOR-Train-3877.scene_instance.json", + "./5/ProcTHOR-Train-3304.scene_instance.json", + "./5/ProcTHOR-Train-3217.scene_instance.json", + "./5/ProcTHOR-Train-3651.scene_instance.json", + "./5/ProcTHOR-Train-3136.scene_instance.json", + "./5/ProcTHOR-Train-3018.scene_instance.json", + "./5/ProcTHOR-Train-3891.scene_instance.json", + "./5/ProcTHOR-Train-3735.scene_instance.json", + "./5/ProcTHOR-Train-3655.scene_instance.json", + "./5/ProcTHOR-Train-3354.scene_instance.json", + "./5/ProcTHOR-Train-3266.scene_instance.json", + "./5/ProcTHOR-Train-3848.scene_instance.json", + "./5/ProcTHOR-Train-3795.scene_instance.json", + "./5/ProcTHOR-Train-3662.scene_instance.json", + "./5/ProcTHOR-Train-3445.scene_instance.json", + "./5/ProcTHOR-Train-3303.scene_instance.json", + "./5/ProcTHOR-Train-3427.scene_instance.json", + "./5/ProcTHOR-Train-3349.scene_instance.json", + "./5/ProcTHOR-Train-3396.scene_instance.json", + "./5/ProcTHOR-Train-3094.scene_instance.json", + "./5/ProcTHOR-Train-3827.scene_instance.json", + "./5/ProcTHOR-Train-3307.scene_instance.json", + "./5/ProcTHOR-Train-3857.scene_instance.json", + "./5/ProcTHOR-Train-3993.scene_instance.json", + "./5/ProcTHOR-Train-3810.scene_instance.json", + "./5/ProcTHOR-Train-3095.scene_instance.json", + "./5/ProcTHOR-Train-3331.scene_instance.json", + "./5/ProcTHOR-Train-3334.scene_instance.json", + "./5/ProcTHOR-Train-3484.scene_instance.json", + "./5/ProcTHOR-Train-3657.scene_instance.json", + "./5/ProcTHOR-Train-3070.scene_instance.json", + "./5/ProcTHOR-Train-3689.scene_instance.json", + "./5/ProcTHOR-Train-3172.scene_instance.json", + "./5/ProcTHOR-Train-3589.scene_instance.json", + "./5/ProcTHOR-Train-3429.scene_instance.json", + "./5/ProcTHOR-Train-3473.scene_instance.json", + "./5/ProcTHOR-Train-3808.scene_instance.json", + "./5/ProcTHOR-Train-3072.scene_instance.json", + "./5/ProcTHOR-Train-3898.scene_instance.json", + "./5/ProcTHOR-Train-3147.scene_instance.json", + "./5/ProcTHOR-Train-3595.scene_instance.json", + "./5/ProcTHOR-Train-3502.scene_instance.json", + "./5/ProcTHOR-Train-3543.scene_instance.json", + "./5/ProcTHOR-Train-3756.scene_instance.json", + "./5/ProcTHOR-Train-3441.scene_instance.json", + "./5/ProcTHOR-Train-3496.scene_instance.json", + "./5/ProcTHOR-Train-3944.scene_instance.json", + "./5/ProcTHOR-Train-3743.scene_instance.json", + "./5/ProcTHOR-Train-3064.scene_instance.json", + "./5/ProcTHOR-Train-3726.scene_instance.json", + "./5/ProcTHOR-Train-3715.scene_instance.json", + "./5/ProcTHOR-Train-3666.scene_instance.json", + "./5/ProcTHOR-Train-3711.scene_instance.json", + "./5/ProcTHOR-Train-3649.scene_instance.json", + "./5/ProcTHOR-Train-3405.scene_instance.json", + "./5/ProcTHOR-Train-3138.scene_instance.json", + "./5/ProcTHOR-Train-3488.scene_instance.json", + "./5/ProcTHOR-Train-3329.scene_instance.json", + "./5/ProcTHOR-Train-3986.scene_instance.json", + "./5/ProcTHOR-Train-3001.scene_instance.json", + "./5/ProcTHOR-Train-3552.scene_instance.json", + "./5/ProcTHOR-Train-3083.scene_instance.json", + "./5/ProcTHOR-Train-3641.scene_instance.json", + "./5/ProcTHOR-Train-3801.scene_instance.json", + "./5/ProcTHOR-Train-3286.scene_instance.json", + "./5/ProcTHOR-Train-3597.scene_instance.json", + "./5/ProcTHOR-Train-3245.scene_instance.json", + "./5/ProcTHOR-Train-3044.scene_instance.json", + "./5/ProcTHOR-Train-3177.scene_instance.json", + "./5/ProcTHOR-Train-3998.scene_instance.json", + "./5/ProcTHOR-Train-3686.scene_instance.json", + "./5/ProcTHOR-Train-3803.scene_instance.json", + "./5/ProcTHOR-Train-3630.scene_instance.json", + "./5/ProcTHOR-Train-3821.scene_instance.json", + "./5/ProcTHOR-Train-3744.scene_instance.json", + "./5/ProcTHOR-Train-3862.scene_instance.json", + "./5/ProcTHOR-Train-3296.scene_instance.json", + "./5/ProcTHOR-Train-3924.scene_instance.json", + "./5/ProcTHOR-Train-3250.scene_instance.json", + "./5/ProcTHOR-Train-3563.scene_instance.json", + "./5/ProcTHOR-Train-3706.scene_instance.json", + "./5/ProcTHOR-Train-3916.scene_instance.json", + "./5/ProcTHOR-Train-3216.scene_instance.json", + "./5/ProcTHOR-Train-3340.scene_instance.json", + "./5/ProcTHOR-Train-3000.scene_instance.json", + "./5/ProcTHOR-Train-3399.scene_instance.json", + "./5/ProcTHOR-Train-3764.scene_instance.json", + "./5/ProcTHOR-Train-3624.scene_instance.json", + "./5/ProcTHOR-Train-3957.scene_instance.json", + "./5/ProcTHOR-Train-3342.scene_instance.json", + "./5/ProcTHOR-Train-3532.scene_instance.json", + "./5/ProcTHOR-Train-3653.scene_instance.json", + "./5/ProcTHOR-Train-3015.scene_instance.json", + "./5/ProcTHOR-Train-3166.scene_instance.json", + "./5/ProcTHOR-Train-3512.scene_instance.json", + "./5/ProcTHOR-Train-3328.scene_instance.json", + "./5/ProcTHOR-Train-3378.scene_instance.json", + "./5/ProcTHOR-Train-3327.scene_instance.json", + "./5/ProcTHOR-Train-3100.scene_instance.json", + "./5/ProcTHOR-Train-3449.scene_instance.json", + "./5/ProcTHOR-Train-3815.scene_instance.json", + "./5/ProcTHOR-Train-3076.scene_instance.json", + "./5/ProcTHOR-Train-3060.scene_instance.json", + "./5/ProcTHOR-Train-3647.scene_instance.json", + "./5/ProcTHOR-Train-3366.scene_instance.json", + "./5/ProcTHOR-Train-3895.scene_instance.json", + "./5/ProcTHOR-Train-3008.scene_instance.json", + "./5/ProcTHOR-Train-3465.scene_instance.json", + "./5/ProcTHOR-Train-3102.scene_instance.json", + "./5/ProcTHOR-Train-3799.scene_instance.json", + "./5/ProcTHOR-Train-3073.scene_instance.json", + "./5/ProcTHOR-Train-3527.scene_instance.json", + "./5/ProcTHOR-Train-3839.scene_instance.json", + "./5/ProcTHOR-Train-3974.scene_instance.json", + "./5/ProcTHOR-Train-3281.scene_instance.json", + "./5/ProcTHOR-Train-3979.scene_instance.json", + "./5/ProcTHOR-Train-3683.scene_instance.json", + "./5/ProcTHOR-Train-3135.scene_instance.json", + "./5/ProcTHOR-Train-3289.scene_instance.json", + "./5/ProcTHOR-Train-3280.scene_instance.json", + "./5/ProcTHOR-Train-3231.scene_instance.json", + "./5/ProcTHOR-Train-3737.scene_instance.json", + "./5/ProcTHOR-Train-3981.scene_instance.json", + "./5/ProcTHOR-Train-3668.scene_instance.json", + "./5/ProcTHOR-Train-3306.scene_instance.json", + "./5/ProcTHOR-Train-3356.scene_instance.json", + "./5/ProcTHOR-Train-3487.scene_instance.json", + "./5/ProcTHOR-Train-3569.scene_instance.json", + "./5/ProcTHOR-Train-3170.scene_instance.json", + "./5/ProcTHOR-Train-3739.scene_instance.json", + "./5/ProcTHOR-Train-3129.scene_instance.json", + "./5/ProcTHOR-Train-3200.scene_instance.json", + "./5/ProcTHOR-Train-3229.scene_instance.json", + "./5/ProcTHOR-Train-3960.scene_instance.json", + "./5/ProcTHOR-Train-3577.scene_instance.json", + "./5/ProcTHOR-Train-3606.scene_instance.json", + "./5/ProcTHOR-Train-3909.scene_instance.json", + "./5/ProcTHOR-Train-3501.scene_instance.json", + "./5/ProcTHOR-Train-3780.scene_instance.json", + "./5/ProcTHOR-Train-3951.scene_instance.json", + "./5/ProcTHOR-Train-3439.scene_instance.json", + "./5/ProcTHOR-Train-3499.scene_instance.json", + "./5/ProcTHOR-Train-3314.scene_instance.json", + "./5/ProcTHOR-Train-3218.scene_instance.json", + "./5/ProcTHOR-Train-3947.scene_instance.json", + "./5/ProcTHOR-Train-3163.scene_instance.json", + "./5/ProcTHOR-Train-3838.scene_instance.json", + "./5/ProcTHOR-Train-3581.scene_instance.json", + "./5/ProcTHOR-Train-3114.scene_instance.json", + "./5/ProcTHOR-Train-3081.scene_instance.json", + "./5/ProcTHOR-Train-3555.scene_instance.json", + "./5/ProcTHOR-Train-3271.scene_instance.json", + "./5/ProcTHOR-Train-3451.scene_instance.json", + "./5/ProcTHOR-Train-3308.scene_instance.json", + "./5/ProcTHOR-Train-3371.scene_instance.json", + "./5/ProcTHOR-Train-3381.scene_instance.json", + "./5/ProcTHOR-Train-3518.scene_instance.json", + "./5/ProcTHOR-Train-3022.scene_instance.json", + "./5/ProcTHOR-Train-3813.scene_instance.json", + "./5/ProcTHOR-Train-3712.scene_instance.json", + "./5/ProcTHOR-Train-3335.scene_instance.json", + "./5/ProcTHOR-Train-3811.scene_instance.json", + "./5/ProcTHOR-Train-3567.scene_instance.json", + "./5/ProcTHOR-Train-3872.scene_instance.json", + "./5/ProcTHOR-Train-3180.scene_instance.json", + "./5/ProcTHOR-Train-3393.scene_instance.json", + "./5/ProcTHOR-Train-3881.scene_instance.json", + "./5/ProcTHOR-Train-3896.scene_instance.json", + "./5/ProcTHOR-Train-3713.scene_instance.json", + "./5/ProcTHOR-Train-3357.scene_instance.json", + "./5/ProcTHOR-Train-3961.scene_instance.json", + "./5/ProcTHOR-Train-3932.scene_instance.json", + "./5/ProcTHOR-Train-3493.scene_instance.json", + "./5/ProcTHOR-Train-3253.scene_instance.json", + "./5/ProcTHOR-Train-3982.scene_instance.json", + "./5/ProcTHOR-Train-3082.scene_instance.json", + "./5/ProcTHOR-Train-3379.scene_instance.json", + "./5/ProcTHOR-Train-3482.scene_instance.json", + "./5/ProcTHOR-Train-3939.scene_instance.json", + "./5/ProcTHOR-Train-3572.scene_instance.json", + "./5/ProcTHOR-Train-3629.scene_instance.json", + "./5/ProcTHOR-Train-3422.scene_instance.json", + "./5/ProcTHOR-Train-3175.scene_instance.json", + "./5/ProcTHOR-Train-3727.scene_instance.json", + "./5/ProcTHOR-Train-3191.scene_instance.json", + "./5/ProcTHOR-Train-3648.scene_instance.json", + "./5/ProcTHOR-Train-3654.scene_instance.json", + "./5/ProcTHOR-Train-3665.scene_instance.json", + "./5/ProcTHOR-Train-3164.scene_instance.json", + "./5/ProcTHOR-Train-3294.scene_instance.json", + "./5/ProcTHOR-Train-3874.scene_instance.json", + "./5/ProcTHOR-Train-3639.scene_instance.json", + "./5/ProcTHOR-Train-3134.scene_instance.json", + "./5/ProcTHOR-Train-3338.scene_instance.json", + "./5/ProcTHOR-Train-3415.scene_instance.json", + "./5/ProcTHOR-Train-3693.scene_instance.json", + "./5/ProcTHOR-Train-3830.scene_instance.json", + "./5/ProcTHOR-Train-3886.scene_instance.json", + "./5/ProcTHOR-Train-3761.scene_instance.json", + "./5/ProcTHOR-Train-3244.scene_instance.json", + "./5/ProcTHOR-Train-3151.scene_instance.json", + "./5/ProcTHOR-Train-3626.scene_instance.json", + "./5/ProcTHOR-Train-3256.scene_instance.json", + "./5/ProcTHOR-Train-3692.scene_instance.json", + "./5/ProcTHOR-Train-3236.scene_instance.json", + "./5/ProcTHOR-Train-3042.scene_instance.json", + "./5/ProcTHOR-Train-3882.scene_instance.json", + "./5/ProcTHOR-Train-3332.scene_instance.json", + "./5/ProcTHOR-Train-3599.scene_instance.json", + "./5/ProcTHOR-Train-3160.scene_instance.json", + "./5/ProcTHOR-Train-3992.scene_instance.json", + "./5/ProcTHOR-Train-3295.scene_instance.json", + "./5/ProcTHOR-Train-3341.scene_instance.json", + "./5/ProcTHOR-Train-3650.scene_instance.json", + "./5/ProcTHOR-Train-3603.scene_instance.json", + "./5/ProcTHOR-Train-3819.scene_instance.json", + "./5/ProcTHOR-Train-3868.scene_instance.json", + "./5/ProcTHOR-Train-3573.scene_instance.json", + "./5/ProcTHOR-Train-3339.scene_instance.json", + "./5/ProcTHOR-Train-3139.scene_instance.json", + "./5/ProcTHOR-Train-3544.scene_instance.json", + "./5/ProcTHOR-Train-3972.scene_instance.json", + "./5/ProcTHOR-Train-3671.scene_instance.json", + "./5/ProcTHOR-Train-3165.scene_instance.json", + "./5/ProcTHOR-Train-3793.scene_instance.json", + "./5/ProcTHOR-Train-3276.scene_instance.json", + "./5/ProcTHOR-Train-3374.scene_instance.json", + "./5/ProcTHOR-Train-3040.scene_instance.json", + "./5/ProcTHOR-Train-3285.scene_instance.json", + "./5/ProcTHOR-Train-3674.scene_instance.json", + "./5/ProcTHOR-Train-3701.scene_instance.json", + "./5/ProcTHOR-Train-3463.scene_instance.json", + "./5/ProcTHOR-Train-3062.scene_instance.json", + "./5/ProcTHOR-Train-3443.scene_instance.json", + "./5/ProcTHOR-Train-3050.scene_instance.json", + "./5/ProcTHOR-Train-3035.scene_instance.json", + "./5/ProcTHOR-Train-3220.scene_instance.json", + "./5/ProcTHOR-Train-3529.scene_instance.json", + "./5/ProcTHOR-Train-3921.scene_instance.json", + "./5/ProcTHOR-Train-3093.scene_instance.json", + "./5/ProcTHOR-Train-3350.scene_instance.json", + "./5/ProcTHOR-Train-3565.scene_instance.json", + "./5/ProcTHOR-Train-3675.scene_instance.json", + "./5/ProcTHOR-Train-3438.scene_instance.json", + "./5/ProcTHOR-Train-3474.scene_instance.json", + "./5/ProcTHOR-Train-3805.scene_instance.json", + "./5/ProcTHOR-Train-3372.scene_instance.json", + "./5/ProcTHOR-Train-3950.scene_instance.json", + "./5/ProcTHOR-Train-3490.scene_instance.json", + "./5/ProcTHOR-Train-3174.scene_instance.json", + "./5/ProcTHOR-Train-3850.scene_instance.json", + "./5/ProcTHOR-Train-3301.scene_instance.json", + "./5/ProcTHOR-Train-3609.scene_instance.json", + "./5/ProcTHOR-Train-3263.scene_instance.json", + "./5/ProcTHOR-Train-3089.scene_instance.json", + "./5/ProcTHOR-Train-3386.scene_instance.json", + "./5/ProcTHOR-Train-3169.scene_instance.json", + "./5/ProcTHOR-Train-3467.scene_instance.json", + "./5/ProcTHOR-Train-3209.scene_instance.json", + "./5/ProcTHOR-Train-3965.scene_instance.json", + "./5/ProcTHOR-Train-3014.scene_instance.json", + "./5/ProcTHOR-Train-3586.scene_instance.json", + "./5/ProcTHOR-Train-3938.scene_instance.json", + "./5/ProcTHOR-Train-3312.scene_instance.json", + "./5/ProcTHOR-Train-3607.scene_instance.json", + "./5/ProcTHOR-Train-3029.scene_instance.json", + "./5/ProcTHOR-Train-3058.scene_instance.json", + "./5/ProcTHOR-Train-3498.scene_instance.json", + "./5/ProcTHOR-Train-3020.scene_instance.json", + "./5/ProcTHOR-Train-3878.scene_instance.json", + "./5/ProcTHOR-Train-3130.scene_instance.json", + "./5/ProcTHOR-Train-3414.scene_instance.json", + "./5/ProcTHOR-Train-3006.scene_instance.json", + "./5/ProcTHOR-Train-3483.scene_instance.json", + "./5/ProcTHOR-Train-3598.scene_instance.json", + "./5/ProcTHOR-Train-3625.scene_instance.json", + "./5/ProcTHOR-Train-3148.scene_instance.json", + "./5/ProcTHOR-Train-3489.scene_instance.json", + "./5/ProcTHOR-Train-3852.scene_instance.json", + "./5/ProcTHOR-Train-3278.scene_instance.json", + "./5/ProcTHOR-Train-3478.scene_instance.json", + "./5/ProcTHOR-Train-3755.scene_instance.json", + "./5/ProcTHOR-Train-3183.scene_instance.json", + "./5/ProcTHOR-Train-3851.scene_instance.json", + "./5/ProcTHOR-Train-3667.scene_instance.json", + "./5/ProcTHOR-Train-3007.scene_instance.json", + "./5/ProcTHOR-Train-3594.scene_instance.json", + "./5/ProcTHOR-Train-3922.scene_instance.json", + "./5/ProcTHOR-Train-3420.scene_instance.json", + "./5/ProcTHOR-Train-3579.scene_instance.json", + "./5/ProcTHOR-Train-3412.scene_instance.json", + "./5/ProcTHOR-Train-3888.scene_instance.json", + "./5/ProcTHOR-Train-3419.scene_instance.json", + "./5/ProcTHOR-Train-3343.scene_instance.json", + "./5/ProcTHOR-Train-3388.scene_instance.json", + "./5/ProcTHOR-Train-3486.scene_instance.json", + "./5/ProcTHOR-Train-3582.scene_instance.json", + "./5/ProcTHOR-Train-3818.scene_instance.json", + "./5/ProcTHOR-Train-3423.scene_instance.json", + "./5/ProcTHOR-Train-3203.scene_instance.json", + "./5/ProcTHOR-Train-3526.scene_instance.json", + "./5/ProcTHOR-Train-3348.scene_instance.json", + "./5/ProcTHOR-Train-3318.scene_instance.json", + "./5/ProcTHOR-Train-3155.scene_instance.json", + "./5/ProcTHOR-Train-3604.scene_instance.json", + "./5/ProcTHOR-Train-3479.scene_instance.json", + "./5/ProcTHOR-Train-3775.scene_instance.json", + "./5/ProcTHOR-Train-3966.scene_instance.json", + "./5/ProcTHOR-Train-3989.scene_instance.json", + "./5/ProcTHOR-Train-3661.scene_instance.json", + "./5/ProcTHOR-Train-3293.scene_instance.json", + "./5/ProcTHOR-Train-3404.scene_instance.json", + "./5/ProcTHOR-Train-3707.scene_instance.json", + "./5/ProcTHOR-Train-3010.scene_instance.json", + "./5/ProcTHOR-Train-3659.scene_instance.json", + "./5/ProcTHOR-Train-3167.scene_instance.json", + "./5/ProcTHOR-Train-3971.scene_instance.json", + "./5/ProcTHOR-Train-3323.scene_instance.json", + "./5/ProcTHOR-Train-3159.scene_instance.json", + "./5/ProcTHOR-Train-3448.scene_instance.json", + "./5/ProcTHOR-Train-3196.scene_instance.json", + "./5/ProcTHOR-Train-3345.scene_instance.json", + "./5/ProcTHOR-Train-3929.scene_instance.json", + "./5/ProcTHOR-Train-3103.scene_instance.json", + "./5/ProcTHOR-Train-3535.scene_instance.json", + "./5/ProcTHOR-Train-3833.scene_instance.json", + "./5/ProcTHOR-Train-3368.scene_instance.json", + "./5/ProcTHOR-Train-3023.scene_instance.json", + "./5/ProcTHOR-Train-3190.scene_instance.json", + "./5/ProcTHOR-Train-3540.scene_instance.json", + "./5/ProcTHOR-Train-3682.scene_instance.json", + "./5/ProcTHOR-Train-3741.scene_instance.json", + "./5/ProcTHOR-Train-3057.scene_instance.json", + "./5/ProcTHOR-Train-3145.scene_instance.json", + "./5/ProcTHOR-Train-3240.scene_instance.json", + "./5/ProcTHOR-Train-3634.scene_instance.json", + "./5/ProcTHOR-Train-3880.scene_instance.json", + "./5/ProcTHOR-Train-3267.scene_instance.json", + "./5/ProcTHOR-Train-3213.scene_instance.json", + "./5/ProcTHOR-Train-3287.scene_instance.json", + "./5/ProcTHOR-Train-3576.scene_instance.json", + "./5/ProcTHOR-Train-3522.scene_instance.json", + "./5/ProcTHOR-Train-3553.scene_instance.json", + "./5/ProcTHOR-Train-3480.scene_instance.json", + "./5/ProcTHOR-Train-3946.scene_instance.json", + "./5/ProcTHOR-Train-3198.scene_instance.json", + "./5/ProcTHOR-Train-3541.scene_instance.json", + "./5/ProcTHOR-Train-3279.scene_instance.json", + "./5/ProcTHOR-Train-3430.scene_instance.json", + "./5/ProcTHOR-Train-3037.scene_instance.json", + "./5/ProcTHOR-Train-3990.scene_instance.json", + "./5/ProcTHOR-Train-3736.scene_instance.json", + "./5/ProcTHOR-Train-3750.scene_instance.json", + "./5/ProcTHOR-Train-3970.scene_instance.json", + "./5/ProcTHOR-Train-3636.scene_instance.json", + "./5/ProcTHOR-Train-3389.scene_instance.json", + "./5/ProcTHOR-Train-3547.scene_instance.json", + "./5/ProcTHOR-Train-3477.scene_instance.json", + "./5/ProcTHOR-Train-3534.scene_instance.json", + "./5/ProcTHOR-Train-3168.scene_instance.json", + "./5/ProcTHOR-Train-3942.scene_instance.json", + "./5/ProcTHOR-Train-3311.scene_instance.json", + "./5/ProcTHOR-Train-3536.scene_instance.json", + "./5/ProcTHOR-Train-3548.scene_instance.json", + "./5/ProcTHOR-Train-3409.scene_instance.json", + "./5/ProcTHOR-Train-3507.scene_instance.json", + "./5/ProcTHOR-Train-3442.scene_instance.json", + "./5/ProcTHOR-Train-3202.scene_instance.json", + "./5/ProcTHOR-Train-3511.scene_instance.json", + "./5/ProcTHOR-Train-3123.scene_instance.json", + "./5/ProcTHOR-Train-3506.scene_instance.json", + "./5/ProcTHOR-Train-3730.scene_instance.json", + "./5/ProcTHOR-Train-3376.scene_instance.json", + "./5/ProcTHOR-Train-3521.scene_instance.json", + "./5/ProcTHOR-Train-3836.scene_instance.json", + "./5/ProcTHOR-Train-3646.scene_instance.json", + "./5/ProcTHOR-Train-3906.scene_instance.json", + "./5/ProcTHOR-Train-3391.scene_instance.json", + "./5/ProcTHOR-Train-3566.scene_instance.json", + "./5/ProcTHOR-Train-3858.scene_instance.json", + "./5/ProcTHOR-Train-3106.scene_instance.json", + "./5/ProcTHOR-Train-3077.scene_instance.json", + "./5/ProcTHOR-Train-3025.scene_instance.json", + "./5/ProcTHOR-Train-3945.scene_instance.json", + "./5/ProcTHOR-Train-3912.scene_instance.json", + "./5/ProcTHOR-Train-3004.scene_instance.json", + "./5/ProcTHOR-Train-3019.scene_instance.json", + "./5/ProcTHOR-Train-3137.scene_instance.json", + "./5/ProcTHOR-Train-3036.scene_instance.json", + "./5/ProcTHOR-Train-3638.scene_instance.json", + "./5/ProcTHOR-Train-3557.scene_instance.json", + "./5/ProcTHOR-Train-3519.scene_instance.json", + "./5/ProcTHOR-Train-3578.scene_instance.json", + "./5/ProcTHOR-Train-3400.scene_instance.json", + "./5/ProcTHOR-Train-3116.scene_instance.json", + "./5/ProcTHOR-Train-3751.scene_instance.json", + "./5/ProcTHOR-Train-3934.scene_instance.json", + "./5/ProcTHOR-Train-3282.scene_instance.json", + "./5/ProcTHOR-Train-3476.scene_instance.json", + "./5/ProcTHOR-Train-3967.scene_instance.json", + "./5/ProcTHOR-Train-3066.scene_instance.json", + "./5/ProcTHOR-Train-3194.scene_instance.json", + "./5/ProcTHOR-Train-3871.scene_instance.json", + "./5/ProcTHOR-Train-3840.scene_instance.json", + "./5/ProcTHOR-Train-3097.scene_instance.json", + "./5/ProcTHOR-Train-3260.scene_instance.json", + "./5/ProcTHOR-Train-3225.scene_instance.json", + "./5/ProcTHOR-Train-3897.scene_instance.json", + "./5/ProcTHOR-Train-3973.scene_instance.json", + "./5/ProcTHOR-Train-3110.scene_instance.json", + "./5/ProcTHOR-Train-3355.scene_instance.json", + "./5/ProcTHOR-Train-3099.scene_instance.json", + "./5/ProcTHOR-Train-3211.scene_instance.json", + "./5/ProcTHOR-Train-3176.scene_instance.json", + "./5/ProcTHOR-Train-3885.scene_instance.json", + "./5/ProcTHOR-Train-3188.scene_instance.json", + "./5/ProcTHOR-Train-3186.scene_instance.json", + "./5/ProcTHOR-Train-3446.scene_instance.json", + "./5/ProcTHOR-Train-3505.scene_instance.json", + "./5/ProcTHOR-Train-3908.scene_instance.json", + "./5/ProcTHOR-Train-3688.scene_instance.json", + "./5/ProcTHOR-Train-3363.scene_instance.json", + "./5/ProcTHOR-Train-3154.scene_instance.json", + "./5/ProcTHOR-Train-3270.scene_instance.json", + "./5/ProcTHOR-Train-3875.scene_instance.json", + "./5/ProcTHOR-Train-3358.scene_instance.json", + "./5/ProcTHOR-Train-3596.scene_instance.json", + "./5/ProcTHOR-Train-3773.scene_instance.json", + "./5/ProcTHOR-Train-3600.scene_instance.json", + "./5/ProcTHOR-Train-3622.scene_instance.json", + "./5/ProcTHOR-Train-3041.scene_instance.json", + "./5/ProcTHOR-Train-3359.scene_instance.json", + "./5/ProcTHOR-Train-3542.scene_instance.json", + "./5/ProcTHOR-Train-3783.scene_instance.json", + "./5/ProcTHOR-Train-3722.scene_instance.json", + "./5/ProcTHOR-Train-3778.scene_instance.json", + "./5/ProcTHOR-Train-3125.scene_instance.json", + "./5/ProcTHOR-Train-3012.scene_instance.json", + "./5/ProcTHOR-Train-3762.scene_instance.json", + "./5/ProcTHOR-Train-3928.scene_instance.json", + "./5/ProcTHOR-Train-3860.scene_instance.json", + "./5/ProcTHOR-Train-3632.scene_instance.json", + "./5/ProcTHOR-Train-3601.scene_instance.json", + "./5/ProcTHOR-Train-3078.scene_instance.json", + "./5/ProcTHOR-Train-3208.scene_instance.json", + "./5/ProcTHOR-Train-3825.scene_instance.json", + "./5/ProcTHOR-Train-3954.scene_instance.json", + "./5/ProcTHOR-Train-3383.scene_instance.json", + "./5/ProcTHOR-Train-3887.scene_instance.json", + "./5/ProcTHOR-Train-3911.scene_instance.json", + "./5/ProcTHOR-Train-3550.scene_instance.json", + "./5/ProcTHOR-Train-3861.scene_instance.json", + "./5/ProcTHOR-Train-3927.scene_instance.json", + "./5/ProcTHOR-Train-3402.scene_instance.json", + "./5/ProcTHOR-Train-3802.scene_instance.json", + "./5/ProcTHOR-Train-3459.scene_instance.json", + "./5/ProcTHOR-Train-3242.scene_instance.json", + "./5/ProcTHOR-Train-3962.scene_instance.json", + "./5/ProcTHOR-Train-3656.scene_instance.json", + "./5/ProcTHOR-Train-3637.scene_instance.json", + "./5/ProcTHOR-Train-3798.scene_instance.json", + "./5/ProcTHOR-Train-3791.scene_instance.json", + "./5/ProcTHOR-Train-3111.scene_instance.json", + "./5/ProcTHOR-Train-3324.scene_instance.json", + "./5/ProcTHOR-Train-3059.scene_instance.json", + "./5/ProcTHOR-Train-3987.scene_instance.json", + "./5/ProcTHOR-Train-3369.scene_instance.json", + "./5/ProcTHOR-Train-3776.scene_instance.json", + "./5/ProcTHOR-Train-3703.scene_instance.json", + "./5/ProcTHOR-Train-3223.scene_instance.json", + "./5/ProcTHOR-Train-3298.scene_instance.json", + "./5/ProcTHOR-Train-3272.scene_instance.json", + "./5/ProcTHOR-Train-3845.scene_instance.json", + "./5/ProcTHOR-Train-3763.scene_instance.json", + "./5/ProcTHOR-Train-3424.scene_instance.json", + "./5/ProcTHOR-Train-3251.scene_instance.json", + "./5/ProcTHOR-Train-3890.scene_instance.json", + "./5/ProcTHOR-Train-3549.scene_instance.json", + "./5/ProcTHOR-Train-3759.scene_instance.json", + "./5/ProcTHOR-Train-3925.scene_instance.json", + "./5/ProcTHOR-Train-3867.scene_instance.json", + "./5/ProcTHOR-Train-3812.scene_instance.json", + "./5/ProcTHOR-Train-3959.scene_instance.json", + "./5/ProcTHOR-Train-3241.scene_instance.json", + "./5/ProcTHOR-Train-3367.scene_instance.json", + "./5/ProcTHOR-Train-3179.scene_instance.json", + "./5/ProcTHOR-Train-3766.scene_instance.json", + "./5/ProcTHOR-Train-3716.scene_instance.json", + "./5/ProcTHOR-Train-3030.scene_instance.json", + "./5/ProcTHOR-Train-3835.scene_instance.json", + "./5/ProcTHOR-Train-3061.scene_instance.json", + "./5/ProcTHOR-Train-3239.scene_instance.json", + "./5/ProcTHOR-Train-3984.scene_instance.json", + "./5/ProcTHOR-Train-3742.scene_instance.json", + "./5/ProcTHOR-Train-3003.scene_instance.json", + "./5/ProcTHOR-Train-3859.scene_instance.json", + "./5/ProcTHOR-Train-3724.scene_instance.json", + "./5/ProcTHOR-Train-3347.scene_instance.json", + "./5/ProcTHOR-Train-3238.scene_instance.json", + "./5/ProcTHOR-Train-3462.scene_instance.json", + "./5/ProcTHOR-Train-3588.scene_instance.json", + "./5/ProcTHOR-Train-3387.scene_instance.json", + "./5/ProcTHOR-Train-3635.scene_instance.json", + "./5/ProcTHOR-Train-3583.scene_instance.json", + "./5/ProcTHOR-Train-3918.scene_instance.json", + "./5/ProcTHOR-Train-3923.scene_instance.json", + "./5/ProcTHOR-Train-3788.scene_instance.json", + "./5/ProcTHOR-Train-3360.scene_instance.json", + "./5/ProcTHOR-Train-3132.scene_instance.json", + "./5/ProcTHOR-Train-3664.scene_instance.json", + "./5/ProcTHOR-Train-3207.scene_instance.json", + "./5/ProcTHOR-Train-3800.scene_instance.json", + "./5/ProcTHOR-Train-3977.scene_instance.json", + "./5/ProcTHOR-Train-3969.scene_instance.json", + "./5/ProcTHOR-Train-3373.scene_instance.json", + "./5/ProcTHOR-Train-3669.scene_instance.json", + "./5/ProcTHOR-Train-3760.scene_instance.json", + "./5/ProcTHOR-Train-3509.scene_instance.json", + "./5/ProcTHOR-Train-3107.scene_instance.json", + "./5/ProcTHOR-Train-3408.scene_instance.json", + "./5/ProcTHOR-Train-3829.scene_instance.json", + "./5/ProcTHOR-Train-3258.scene_instance.json", + "./5/ProcTHOR-Train-3685.scene_instance.json", + "./5/ProcTHOR-Train-3952.scene_instance.json", + "./5/ProcTHOR-Train-3380.scene_instance.json", + "./5/ProcTHOR-Train-3681.scene_instance.json", + "./5/ProcTHOR-Train-3290.scene_instance.json", + "./5/ProcTHOR-Train-3955.scene_instance.json", + "./5/ProcTHOR-Train-3844.scene_instance.json", + "./5/ProcTHOR-Train-3197.scene_instance.json", + "./5/ProcTHOR-Train-3181.scene_instance.json", + "./5/ProcTHOR-Train-3525.scene_instance.json", + "./5/ProcTHOR-Train-3702.scene_instance.json", + "./5/ProcTHOR-Train-3935.scene_instance.json", + "./5/ProcTHOR-Train-3709.scene_instance.json", + "./5/ProcTHOR-Train-3065.scene_instance.json", + "./5/ProcTHOR-Train-3728.scene_instance.json", + "./5/ProcTHOR-Train-3828.scene_instance.json", + "./5/ProcTHOR-Train-3876.scene_instance.json", + "./5/ProcTHOR-Train-3627.scene_instance.json", + "./5/ProcTHOR-Train-3162.scene_instance.json", + "./5/ProcTHOR-Train-3252.scene_instance.json", + "./5/ProcTHOR-Train-3426.scene_instance.json", + "./5/ProcTHOR-Train-3865.scene_instance.json", + "./5/ProcTHOR-Train-3752.scene_instance.json", + "./5/ProcTHOR-Train-3262.scene_instance.json", + "./5/ProcTHOR-Train-3440.scene_instance.json", + "./5/ProcTHOR-Train-3291.scene_instance.json", + "./5/ProcTHOR-Train-3941.scene_instance.json", + "./5/ProcTHOR-Train-3817.scene_instance.json", + "./5/ProcTHOR-Train-3640.scene_instance.json", + "./5/ProcTHOR-Train-3546.scene_instance.json", + "./5/ProcTHOR-Train-3621.scene_instance.json", + "./5/ProcTHOR-Train-3749.scene_instance.json", + "./5/ProcTHOR-Train-3733.scene_instance.json", + "./5/ProcTHOR-Train-3300.scene_instance.json", + "./5/ProcTHOR-Train-3900.scene_instance.json", + "./5/ProcTHOR-Train-3591.scene_instance.json", + "./5/ProcTHOR-Train-3322.scene_instance.json", + "./5/ProcTHOR-Train-3504.scene_instance.json", + "./5/ProcTHOR-Train-3320.scene_instance.json", + "./5/ProcTHOR-Train-3670.scene_instance.json", + "./5/ProcTHOR-Train-3447.scene_instance.json", + "./5/ProcTHOR-Train-3694.scene_instance.json", + "./5/ProcTHOR-Train-3027.scene_instance.json", + "./5/ProcTHOR-Train-3026.scene_instance.json", + "./5/ProcTHOR-Train-3976.scene_instance.json", + "./5/ProcTHOR-Train-3615.scene_instance.json", + "./5/ProcTHOR-Train-3684.scene_instance.json", + "./5/ProcTHOR-Train-3823.scene_instance.json", + "./5/ProcTHOR-Train-3619.scene_instance.json", + "./5/ProcTHOR-Train-3842.scene_instance.json", + "./5/ProcTHOR-Train-3514.scene_instance.json", + "./5/ProcTHOR-Train-3696.scene_instance.json", + "./5/ProcTHOR-Train-3753.scene_instance.json", + "./5/ProcTHOR-Train-3305.scene_instance.json", + "./5/ProcTHOR-Train-3513.scene_instance.json", + "./5/ProcTHOR-Train-3492.scene_instance.json", + "./5/ProcTHOR-Train-3264.scene_instance.json", + "./5/ProcTHOR-Train-3520.scene_instance.json", + "./5/ProcTHOR-Train-3826.scene_instance.json", + "./5/ProcTHOR-Train-3394.scene_instance.json", + "./5/ProcTHOR-Train-3410.scene_instance.json", + "./5/ProcTHOR-Train-3705.scene_instance.json", + "./5/ProcTHOR-Train-3517.scene_instance.json", + "./5/ProcTHOR-Train-3452.scene_instance.json", + "./5/ProcTHOR-Train-3416.scene_instance.json", + "./5/ProcTHOR-Train-3786.scene_instance.json", + "./5/ProcTHOR-Train-3275.scene_instance.json", + "./5/ProcTHOR-Train-3054.scene_instance.json", + "./5/ProcTHOR-Train-3781.scene_instance.json", + "./5/ProcTHOR-Train-3013.scene_instance.json", + "./5/ProcTHOR-Train-3352.scene_instance.json", + "./5/ProcTHOR-Train-3375.scene_instance.json", + "./5/ProcTHOR-Train-3988.scene_instance.json", + "./5/ProcTHOR-Train-3283.scene_instance.json", + "./5/ProcTHOR-Train-3259.scene_instance.json", + "./5/ProcTHOR-Train-3038.scene_instance.json", + "./5/ProcTHOR-Train-3559.scene_instance.json", + "./5/ProcTHOR-Train-3112.scene_instance.json", + "./5/ProcTHOR-Train-3096.scene_instance.json", + "./5/ProcTHOR-Train-3765.scene_instance.json", + "./5/ProcTHOR-Train-3628.scene_instance.json", + "./5/ProcTHOR-Train-3337.scene_instance.json", + "./5/ProcTHOR-Train-3178.scene_instance.json", + "./5/ProcTHOR-Train-3185.scene_instance.json", + "./5/ProcTHOR-Train-3907.scene_instance.json", + "./5/ProcTHOR-Train-3551.scene_instance.json", + "./5/ProcTHOR-Train-3084.scene_instance.json", + "./5/ProcTHOR-Train-3524.scene_instance.json", + "./5/ProcTHOR-Train-3910.scene_instance.json", + "./5/ProcTHOR-Train-3086.scene_instance.json", + "./5/ProcTHOR-Train-3406.scene_instance.json", + "./5/ProcTHOR-Train-3353.scene_instance.json", + "./5/ProcTHOR-Train-3980.scene_instance.json", + "./5/ProcTHOR-Train-3466.scene_instance.json", + "./5/ProcTHOR-Train-3700.scene_instance.json", + "./5/ProcTHOR-Train-3570.scene_instance.json", + "./5/ProcTHOR-Train-3233.scene_instance.json", + "./5/ProcTHOR-Train-3770.scene_instance.json", + "./5/ProcTHOR-Train-3497.scene_instance.json", + "./5/ProcTHOR-Train-3017.scene_instance.json", + "./5/ProcTHOR-Train-3221.scene_instance.json", + "./5/ProcTHOR-Train-3754.scene_instance.json", + "./5/ProcTHOR-Train-3021.scene_instance.json", + "./5/ProcTHOR-Train-3870.scene_instance.json", + "./5/ProcTHOR-Train-3717.scene_instance.json", + "./5/ProcTHOR-Train-3710.scene_instance.json", + "./5/ProcTHOR-Train-3365.scene_instance.json", + "./5/ProcTHOR-Train-3854.scene_instance.json", + "./5/ProcTHOR-Train-3069.scene_instance.json", + "./5/ProcTHOR-Train-3856.scene_instance.json", + "./5/ProcTHOR-Train-3673.scene_instance.json", + "./5/ProcTHOR-Train-3153.scene_instance.json", + "./5/ProcTHOR-Train-3471.scene_instance.json", + "./5/ProcTHOR-Train-3182.scene_instance.json", + "./5/ProcTHOR-Train-3958.scene_instance.json", + "./5/ProcTHOR-Train-3362.scene_instance.json", + "./5/ProcTHOR-Train-3593.scene_instance.json", + "./5/ProcTHOR-Train-3232.scene_instance.json", + "./5/ProcTHOR-Train-3587.scene_instance.json", + "./5/ProcTHOR-Train-3249.scene_instance.json", + "./5/ProcTHOR-Train-3052.scene_instance.json", + "./5/ProcTHOR-Train-3071.scene_instance.json", + "./5/ProcTHOR-Train-3725.scene_instance.json", + "./5/ProcTHOR-Train-3206.scene_instance.json", + "./5/ProcTHOR-Train-3382.scene_instance.json", + "./5/ProcTHOR-Train-3118.scene_instance.json", + "./5/ProcTHOR-Train-3537.scene_instance.json", + "./5/ProcTHOR-Train-3500.scene_instance.json", + "./5/ProcTHOR-Train-3403.scene_instance.json", + "./5/ProcTHOR-Train-3663.scene_instance.json", + "./5/ProcTHOR-Train-3468.scene_instance.json", + "./5/ProcTHOR-Train-3222.scene_instance.json", + "./5/ProcTHOR-Train-3580.scene_instance.json", + "./5/ProcTHOR-Train-3146.scene_instance.json", + "./5/ProcTHOR-Train-3075.scene_instance.json", + "./5/ProcTHOR-Train-3782.scene_instance.json", + "./5/ProcTHOR-Train-3672.scene_instance.json", + "./5/ProcTHOR-Train-3047.scene_instance.json", + "./5/ProcTHOR-Train-3117.scene_instance.json", + "./5/ProcTHOR-Train-3785.scene_instance.json", + "./5/ProcTHOR-Train-3643.scene_instance.json", + "./5/ProcTHOR-Train-3265.scene_instance.json", + "./5/ProcTHOR-Train-3212.scene_instance.json", + "./5/ProcTHOR-Train-3115.scene_instance.json", + "./5/ProcTHOR-Train-3554.scene_instance.json", + "./5/ProcTHOR-Train-3034.scene_instance.json", + "./5/ProcTHOR-Train-3919.scene_instance.json", + "./5/ProcTHOR-Train-3968.scene_instance.json", + "./5/ProcTHOR-Train-3128.scene_instance.json", + "./5/ProcTHOR-Train-3158.scene_instance.json", + "./5/ProcTHOR-Train-3319.scene_instance.json", + "./5/ProcTHOR-Train-3292.scene_instance.json", + "./5/ProcTHOR-Train-3431.scene_instance.json", + "./5/ProcTHOR-Train-3777.scene_instance.json", + "./5/ProcTHOR-Train-3219.scene_instance.json", + "./5/ProcTHOR-Train-3297.scene_instance.json", + "./5/ProcTHOR-Train-3869.scene_instance.json", + "./5/ProcTHOR-Train-3978.scene_instance.json", + "./5/ProcTHOR-Train-3204.scene_instance.json", + "./5/ProcTHOR-Train-3794.scene_instance.json", + "./5/ProcTHOR-Train-3746.scene_instance.json", + "./5/ProcTHOR-Train-3199.scene_instance.json", + "./5/ProcTHOR-Train-3321.scene_instance.json", + "./5/ProcTHOR-Train-3214.scene_instance.json", + "./5/ProcTHOR-Train-3807.scene_instance.json", + "./5/ProcTHOR-Train-3407.scene_instance.json", + "./5/ProcTHOR-Train-3814.scene_instance.json", + "./5/ProcTHOR-Train-3126.scene_instance.json", + "./5/ProcTHOR-Train-3472.scene_instance.json", + "./5/ProcTHOR-Train-3824.scene_instance.json", + "./5/ProcTHOR-Train-3571.scene_instance.json", + "./5/ProcTHOR-Train-3063.scene_instance.json", + "./5/ProcTHOR-Train-3704.scene_instance.json", + "./5/ProcTHOR-Train-3523.scene_instance.json", + "./5/ProcTHOR-Train-3481.scene_instance.json", + "./5/ProcTHOR-Train-3046.scene_instance.json", + "./5/ProcTHOR-Train-3864.scene_instance.json", + "./5/ProcTHOR-Train-3899.scene_instance.json", + "./5/ProcTHOR-Train-3491.scene_instance.json", + "./5/ProcTHOR-Train-3585.scene_instance.json", + "./5/ProcTHOR-Train-3456.scene_instance.json", + "./5/ProcTHOR-Train-3816.scene_instance.json", + "./5/ProcTHOR-Train-3884.scene_instance.json", + "./5/ProcTHOR-Train-3120.scene_instance.json", + "./5/ProcTHOR-Train-3779.scene_instance.json", + "./5/ProcTHOR-Train-3432.scene_instance.json", + "./5/ProcTHOR-Train-3189.scene_instance.json", + "./5/ProcTHOR-Train-3144.scene_instance.json", + "./5/ProcTHOR-Train-3184.scene_instance.json", + "./5/ProcTHOR-Train-3774.scene_instance.json", + "./5/ProcTHOR-Train-3930.scene_instance.json", + "./5/ProcTHOR-Train-3926.scene_instance.json", + "./5/ProcTHOR-Train-3866.scene_instance.json", + "./5/ProcTHOR-Train-3723.scene_instance.json", + "./5/ProcTHOR-Train-3269.scene_instance.json", + "./5/ProcTHOR-Train-3385.scene_instance.json", + "./5/ProcTHOR-Train-3092.scene_instance.json", + "./5/ProcTHOR-Train-3797.scene_instance.json", + "./5/ProcTHOR-Train-3469.scene_instance.json", + "./5/ProcTHOR-Train-3002.scene_instance.json", + "./5/ProcTHOR-Train-3931.scene_instance.json", + "./5/ProcTHOR-Train-3562.scene_instance.json", + "./5/ProcTHOR-Train-3227.scene_instance.json", + "./5/ProcTHOR-Train-3748.scene_instance.json", + "./5/ProcTHOR-Train-3254.scene_instance.json", + "./5/ProcTHOR-Train-3697.scene_instance.json", + "./5/ProcTHOR-Train-3652.scene_instance.json", + "./5/ProcTHOR-Train-3631.scene_instance.json", + "./5/ProcTHOR-Train-3224.scene_instance.json", + "./5/ProcTHOR-Train-3455.scene_instance.json", + "./5/ProcTHOR-Train-3143.scene_instance.json", + "./5/ProcTHOR-Train-3457.scene_instance.json", + "./5/ProcTHOR-Train-3453.scene_instance.json", + "./5/ProcTHOR-Train-3485.scene_instance.json", + "./5/ProcTHOR-Train-3863.scene_instance.json", + "./5/ProcTHOR-Train-3005.scene_instance.json", + "./5/ProcTHOR-Train-3747.scene_instance.json", + "./5/ProcTHOR-Train-3806.scene_instance.json", + "./5/ProcTHOR-Train-3067.scene_instance.json", + "./5/ProcTHOR-Train-3299.scene_instance.json", + "./5/ProcTHOR-Train-3193.scene_instance.json", + "./5/ProcTHOR-Train-3274.scene_instance.json", + "./5/ProcTHOR-Train-3458.scene_instance.json", + "./5/ProcTHOR-Train-3837.scene_instance.json", + "./5/ProcTHOR-Train-3336.scene_instance.json", + "./5/ProcTHOR-Train-3528.scene_instance.json", + "./5/ProcTHOR-Train-3470.scene_instance.json", + "./5/ProcTHOR-Train-3608.scene_instance.json", + "./5/ProcTHOR-Train-3642.scene_instance.json", + "./5/ProcTHOR-Train-3949.scene_instance.json", + "./5/ProcTHOR-Train-3758.scene_instance.json", + "./5/ProcTHOR-Train-3195.scene_instance.json", + "./5/ProcTHOR-Train-3568.scene_instance.json", + "./5/ProcTHOR-Train-3226.scene_instance.json", + "./5/ProcTHOR-Train-3377.scene_instance.json", + "./5/ProcTHOR-Train-3171.scene_instance.json", + "./5/ProcTHOR-Train-3418.scene_instance.json", + "./5/ProcTHOR-Train-3248.scene_instance.json", + "./5/ProcTHOR-Train-3605.scene_instance.json", + "./5/ProcTHOR-Train-3326.scene_instance.json", + "./5/ProcTHOR-Train-3043.scene_instance.json", + "./5/ProcTHOR-Train-3390.scene_instance.json", + "./5/ProcTHOR-Train-3796.scene_instance.json", + "./5/ProcTHOR-Train-3124.scene_instance.json", + "./5/ProcTHOR-Train-3849.scene_instance.json", + "./5/ProcTHOR-Train-3079.scene_instance.json", + "./5/ProcTHOR-Train-3309.scene_instance.json", + "./5/ProcTHOR-Train-3613.scene_instance.json", + "./5/ProcTHOR-Train-3841.scene_instance.json", + "./5/ProcTHOR-Train-3545.scene_instance.json", + "./5/ProcTHOR-Train-3104.scene_instance.json", + "./5/ProcTHOR-Train-3676.scene_instance.json", + "./5/ProcTHOR-Train-3150.scene_instance.json", + "./5/ProcTHOR-Train-3450.scene_instance.json", + "./5/ProcTHOR-Train-3745.scene_instance.json", + "./5/ProcTHOR-Train-3119.scene_instance.json", + "./5/ProcTHOR-Train-3234.scene_instance.json", + "./5/ProcTHOR-Train-3612.scene_instance.json", + "./5/ProcTHOR-Train-3464.scene_instance.json", + "./5/ProcTHOR-Train-3718.scene_instance.json", + "./5/ProcTHOR-Train-3243.scene_instance.json", + "./5/ProcTHOR-Train-3658.scene_instance.json", + "./5/ProcTHOR-Train-3846.scene_instance.json", + "./5/ProcTHOR-Train-3330.scene_instance.json", + "./5/ProcTHOR-Train-3729.scene_instance.json", + "./5/ProcTHOR-Train-3257.scene_instance.json", + "./5/ProcTHOR-Train-3995.scene_instance.json", + "./5/ProcTHOR-Train-3098.scene_instance.json", + "./5/ProcTHOR-Train-3215.scene_instance.json", + "./5/ProcTHOR-Train-3531.scene_instance.json", + "./5/ProcTHOR-Train-3917.scene_instance.json", + "./5/ProcTHOR-Train-3080.scene_instance.json", + "./5/ProcTHOR-Train-3645.scene_instance.json", + "./5/ProcTHOR-Train-3843.scene_instance.json", + "./5/ProcTHOR-Train-3933.scene_instance.json", + "./5/ProcTHOR-Train-3719.scene_instance.json", + "./5/ProcTHOR-Train-3288.scene_instance.json", + "./5/ProcTHOR-Train-3561.scene_instance.json", + "./5/ProcTHOR-Train-3913.scene_instance.json", + "./5/ProcTHOR-Train-3495.scene_instance.json", + "./5/ProcTHOR-Train-3680.scene_instance.json", + "./5/ProcTHOR-Train-3575.scene_instance.json", + "./5/ProcTHOR-Train-3346.scene_instance.json", + "./5/ProcTHOR-Train-3133.scene_instance.json", + "./5/ProcTHOR-Train-3325.scene_instance.json", + "./5/ProcTHOR-Train-3161.scene_instance.json", + "./5/ProcTHOR-Train-3045.scene_instance.json", + "./5/ProcTHOR-Train-3533.scene_instance.json", + "./5/ProcTHOR-Train-3809.scene_instance.json", + "./5/ProcTHOR-Train-3940.scene_instance.json", + "./5/ProcTHOR-Train-3721.scene_instance.json", + "./5/ProcTHOR-Train-3031.scene_instance.json", + "./5/ProcTHOR-Train-3109.scene_instance.json", + "./5/ProcTHOR-Train-3820.scene_instance.json", + "./5/ProcTHOR-Train-3268.scene_instance.json", + "./5/ProcTHOR-Train-3187.scene_instance.json", + "./5/ProcTHOR-Train-3009.scene_instance.json", + "./5/ProcTHOR-Train-3351.scene_instance.json", + "./5/ProcTHOR-Train-3804.scene_instance.json", + "./5/ProcTHOR-Train-3894.scene_instance.json", + "./5/ProcTHOR-Train-3395.scene_instance.json", + "./5/ProcTHOR-Train-3564.scene_instance.json", + "./5/ProcTHOR-Train-3433.scene_instance.json", + "./5/ProcTHOR-Train-3454.scene_instance.json", + "./5/ProcTHOR-Train-3503.scene_instance.json", + "./5/ProcTHOR-Train-3461.scene_instance.json", + "./5/ProcTHOR-Train-3398.scene_instance.json", + "./5/ProcTHOR-Train-3515.scene_instance.json", + "./5/ProcTHOR-Train-3460.scene_instance.json", + "./5/ProcTHOR-Train-3617.scene_instance.json", + "./5/ProcTHOR-Train-3943.scene_instance.json", + "./5/ProcTHOR-Train-3530.scene_instance.json", + "./5/ProcTHOR-Train-3421.scene_instance.json", + "./5/ProcTHOR-Train-3024.scene_instance.json", + "./5/ProcTHOR-Train-3920.scene_instance.json", + "./5/ProcTHOR-Train-3088.scene_instance.json", + "./5/ProcTHOR-Train-3417.scene_instance.json", + "./5/ProcTHOR-Train-3313.scene_instance.json", + "./5/ProcTHOR-Train-3068.scene_instance.json", + "./5/ProcTHOR-Train-3937.scene_instance.json", + "./5/ProcTHOR-Train-3771.scene_instance.json", + "./5/ProcTHOR-Train-3016.scene_instance.json", + "./5/ProcTHOR-Train-3855.scene_instance.json", + "./5/ProcTHOR-Train-3948.scene_instance.json", + "./5/ProcTHOR-Train-3832.scene_instance.json", + "./5/ProcTHOR-Train-3370.scene_instance.json", + "./5/ProcTHOR-Train-3915.scene_instance.json", + "./5/ProcTHOR-Train-3757.scene_instance.json", + "./5/ProcTHOR-Train-3996.scene_instance.json", + "./5/ProcTHOR-Train-3055.scene_instance.json", + "./5/ProcTHOR-Train-3333.scene_instance.json", + "./5/ProcTHOR-Train-3425.scene_instance.json", + "./5/ProcTHOR-Train-3173.scene_instance.json", + "./5/ProcTHOR-Train-3122.scene_instance.json", + "./5/ProcTHOR-Train-3975.scene_instance.json", + "./5/ProcTHOR-Train-3228.scene_instance.json", + "./5/ProcTHOR-Train-3284.scene_instance.json", + "./5/ProcTHOR-Train-3879.scene_instance.json", + "./5/ProcTHOR-Train-3956.scene_instance.json", + "./5/ProcTHOR-Train-3698.scene_instance.json", + "./5/ProcTHOR-Train-3032.scene_instance.json", + "./5/ProcTHOR-Train-3091.scene_instance.json", + "./5/ProcTHOR-Train-3883.scene_instance.json", + "./5/ProcTHOR-Train-3768.scene_instance.json", + "./5/ProcTHOR-Train-3142.scene_instance.json", + "./5/ProcTHOR-Train-3790.scene_instance.json", + "./5/ProcTHOR-Train-3997.scene_instance.json", + "./5/ProcTHOR-Train-3679.scene_instance.json", + "./5/ProcTHOR-Train-3769.scene_instance.json", + "./5/ProcTHOR-Train-3602.scene_instance.json", + "./5/ProcTHOR-Train-3401.scene_instance.json", + "./5/ProcTHOR-Train-3087.scene_instance.json", + "./5/ProcTHOR-Train-3205.scene_instance.json", + "./5/ProcTHOR-Train-3317.scene_instance.json", + "./5/ProcTHOR-Train-3152.scene_instance.json", + "./5/ProcTHOR-Train-3574.scene_instance.json", + "./5/ProcTHOR-Train-3853.scene_instance.json", + "./5/ProcTHOR-Train-3437.scene_instance.json", + "./5/ProcTHOR-Train-3556.scene_instance.json", + "./5/ProcTHOR-Train-3614.scene_instance.json", + "./5/ProcTHOR-Train-3127.scene_instance.json", + "./5/ProcTHOR-Train-3731.scene_instance.json", + "./5/ProcTHOR-Train-3964.scene_instance.json", + "./5/ProcTHOR-Train-3623.scene_instance.json", + "./5/ProcTHOR-Train-3411.scene_instance.json", + "./5/ProcTHOR-Train-3994.scene_instance.json", + "./5/ProcTHOR-Train-3831.scene_instance.json", + "./5/ProcTHOR-Train-3695.scene_instance.json", + "./5/ProcTHOR-Train-3792.scene_instance.json", + "./5/ProcTHOR-Train-3108.scene_instance.json", + "./5/ProcTHOR-Train-3892.scene_instance.json", + "./5/ProcTHOR-Train-3903.scene_instance.json", + "./5/ProcTHOR-Train-3905.scene_instance.json", + "./5/ProcTHOR-Train-3508.scene_instance.json", + "./5/ProcTHOR-Train-3316.scene_instance.json", + "./5/ProcTHOR-Train-3914.scene_instance.json", + "./5/ProcTHOR-Train-3277.scene_instance.json", + "./5/ProcTHOR-Train-3690.scene_instance.json", + "./4/ProcTHOR-Train-2250.scene_instance.json", + "./4/ProcTHOR-Train-2679.scene_instance.json", + "./4/ProcTHOR-Train-2826.scene_instance.json", + "./4/ProcTHOR-Train-2344.scene_instance.json", + "./4/ProcTHOR-Train-2139.scene_instance.json", + "./4/ProcTHOR-Train-2929.scene_instance.json", + "./4/ProcTHOR-Train-2362.scene_instance.json", + "./4/ProcTHOR-Train-2341.scene_instance.json", + "./4/ProcTHOR-Train-2110.scene_instance.json", + "./4/ProcTHOR-Train-2007.scene_instance.json", + "./4/ProcTHOR-Train-2445.scene_instance.json", + "./4/ProcTHOR-Train-2765.scene_instance.json", + "./4/ProcTHOR-Train-2766.scene_instance.json", + "./4/ProcTHOR-Train-2209.scene_instance.json", + "./4/ProcTHOR-Train-2580.scene_instance.json", + "./4/ProcTHOR-Train-2609.scene_instance.json", + "./4/ProcTHOR-Train-2718.scene_instance.json", + "./4/ProcTHOR-Train-2769.scene_instance.json", + "./4/ProcTHOR-Train-2170.scene_instance.json", + "./4/ProcTHOR-Train-2473.scene_instance.json", + "./4/ProcTHOR-Train-2891.scene_instance.json", + "./4/ProcTHOR-Train-2090.scene_instance.json", + "./4/ProcTHOR-Train-2457.scene_instance.json", + "./4/ProcTHOR-Train-2747.scene_instance.json", + "./4/ProcTHOR-Train-2268.scene_instance.json", + "./4/ProcTHOR-Train-2572.scene_instance.json", + "./4/ProcTHOR-Train-2515.scene_instance.json", + "./4/ProcTHOR-Train-2920.scene_instance.json", + "./4/ProcTHOR-Train-2334.scene_instance.json", + "./4/ProcTHOR-Train-2017.scene_instance.json", + "./4/ProcTHOR-Train-2158.scene_instance.json", + "./4/ProcTHOR-Train-2967.scene_instance.json", + "./4/ProcTHOR-Train-2412.scene_instance.json", + "./4/ProcTHOR-Train-2157.scene_instance.json", + "./4/ProcTHOR-Train-2476.scene_instance.json", + "./4/ProcTHOR-Train-2607.scene_instance.json", + "./4/ProcTHOR-Train-2527.scene_instance.json", + "./4/ProcTHOR-Train-2155.scene_instance.json", + "./4/ProcTHOR-Train-2096.scene_instance.json", + "./4/ProcTHOR-Train-2091.scene_instance.json", + "./4/ProcTHOR-Train-2673.scene_instance.json", + "./4/ProcTHOR-Train-2191.scene_instance.json", + "./4/ProcTHOR-Train-2085.scene_instance.json", + "./4/ProcTHOR-Train-2864.scene_instance.json", + "./4/ProcTHOR-Train-2723.scene_instance.json", + "./4/ProcTHOR-Train-2342.scene_instance.json", + "./4/ProcTHOR-Train-2044.scene_instance.json", + "./4/ProcTHOR-Train-2449.scene_instance.json", + "./4/ProcTHOR-Train-2592.scene_instance.json", + "./4/ProcTHOR-Train-2708.scene_instance.json", + "./4/ProcTHOR-Train-2646.scene_instance.json", + "./4/ProcTHOR-Train-2540.scene_instance.json", + "./4/ProcTHOR-Train-2519.scene_instance.json", + "./4/ProcTHOR-Train-2302.scene_instance.json", + "./4/ProcTHOR-Train-2721.scene_instance.json", + "./4/ProcTHOR-Train-2905.scene_instance.json", + "./4/ProcTHOR-Train-2001.scene_instance.json", + "./4/ProcTHOR-Train-2013.scene_instance.json", + "./4/ProcTHOR-Train-2029.scene_instance.json", + "./4/ProcTHOR-Train-2965.scene_instance.json", + "./4/ProcTHOR-Train-2689.scene_instance.json", + "./4/ProcTHOR-Train-2906.scene_instance.json", + "./4/ProcTHOR-Train-2537.scene_instance.json", + "./4/ProcTHOR-Train-2620.scene_instance.json", + "./4/ProcTHOR-Train-2575.scene_instance.json", + "./4/ProcTHOR-Train-2851.scene_instance.json", + "./4/ProcTHOR-Train-2143.scene_instance.json", + "./4/ProcTHOR-Train-2202.scene_instance.json", + "./4/ProcTHOR-Train-2348.scene_instance.json", + "./4/ProcTHOR-Train-2364.scene_instance.json", + "./4/ProcTHOR-Train-2423.scene_instance.json", + "./4/ProcTHOR-Train-2333.scene_instance.json", + "./4/ProcTHOR-Train-2890.scene_instance.json", + "./4/ProcTHOR-Train-2557.scene_instance.json", + "./4/ProcTHOR-Train-2217.scene_instance.json", + "./4/ProcTHOR-Train-2858.scene_instance.json", + "./4/ProcTHOR-Train-2995.scene_instance.json", + "./4/ProcTHOR-Train-2306.scene_instance.json", + "./4/ProcTHOR-Train-2045.scene_instance.json", + "./4/ProcTHOR-Train-2131.scene_instance.json", + "./4/ProcTHOR-Train-2844.scene_instance.json", + "./4/ProcTHOR-Train-2313.scene_instance.json", + "./4/ProcTHOR-Train-2511.scene_instance.json", + "./4/ProcTHOR-Train-2456.scene_instance.json", + "./4/ProcTHOR-Train-2875.scene_instance.json", + "./4/ProcTHOR-Train-2012.scene_instance.json", + "./4/ProcTHOR-Train-2969.scene_instance.json", + "./4/ProcTHOR-Train-2654.scene_instance.json", + "./4/ProcTHOR-Train-2018.scene_instance.json", + "./4/ProcTHOR-Train-2639.scene_instance.json", + "./4/ProcTHOR-Train-2089.scene_instance.json", + "./4/ProcTHOR-Train-2086.scene_instance.json", + "./4/ProcTHOR-Train-2644.scene_instance.json", + "./4/ProcTHOR-Train-2379.scene_instance.json", + "./4/ProcTHOR-Train-2072.scene_instance.json", + "./4/ProcTHOR-Train-2789.scene_instance.json", + "./4/ProcTHOR-Train-2754.scene_instance.json", + "./4/ProcTHOR-Train-2821.scene_instance.json", + "./4/ProcTHOR-Train-2800.scene_instance.json", + "./4/ProcTHOR-Train-2146.scene_instance.json", + "./4/ProcTHOR-Train-2349.scene_instance.json", + "./4/ProcTHOR-Train-2728.scene_instance.json", + "./4/ProcTHOR-Train-2487.scene_instance.json", + "./4/ProcTHOR-Train-2206.scene_instance.json", + "./4/ProcTHOR-Train-2590.scene_instance.json", + "./4/ProcTHOR-Train-2267.scene_instance.json", + "./4/ProcTHOR-Train-2645.scene_instance.json", + "./4/ProcTHOR-Train-2845.scene_instance.json", + "./4/ProcTHOR-Train-2245.scene_instance.json", + "./4/ProcTHOR-Train-2594.scene_instance.json", + "./4/ProcTHOR-Train-2022.scene_instance.json", + "./4/ProcTHOR-Train-2014.scene_instance.json", + "./4/ProcTHOR-Train-2070.scene_instance.json", + "./4/ProcTHOR-Train-2138.scene_instance.json", + "./4/ProcTHOR-Train-2479.scene_instance.json", + "./4/ProcTHOR-Train-2409.scene_instance.json", + "./4/ProcTHOR-Train-2795.scene_instance.json", + "./4/ProcTHOR-Train-2311.scene_instance.json", + "./4/ProcTHOR-Train-2518.scene_instance.json", + "./4/ProcTHOR-Train-2736.scene_instance.json", + "./4/ProcTHOR-Train-2309.scene_instance.json", + "./4/ProcTHOR-Train-2434.scene_instance.json", + "./4/ProcTHOR-Train-2615.scene_instance.json", + "./4/ProcTHOR-Train-2405.scene_instance.json", + "./4/ProcTHOR-Train-2481.scene_instance.json", + "./4/ProcTHOR-Train-2533.scene_instance.json", + "./4/ProcTHOR-Train-2073.scene_instance.json", + "./4/ProcTHOR-Train-2972.scene_instance.json", + "./4/ProcTHOR-Train-2771.scene_instance.json", + "./4/ProcTHOR-Train-2997.scene_instance.json", + "./4/ProcTHOR-Train-2878.scene_instance.json", + "./4/ProcTHOR-Train-2692.scene_instance.json", + "./4/ProcTHOR-Train-2917.scene_instance.json", + "./4/ProcTHOR-Train-2813.scene_instance.json", + "./4/ProcTHOR-Train-2716.scene_instance.json", + "./4/ProcTHOR-Train-2656.scene_instance.json", + "./4/ProcTHOR-Train-2797.scene_instance.json", + "./4/ProcTHOR-Train-2447.scene_instance.json", + "./4/ProcTHOR-Train-2054.scene_instance.json", + "./4/ProcTHOR-Train-2953.scene_instance.json", + "./4/ProcTHOR-Train-2347.scene_instance.json", + "./4/ProcTHOR-Train-2402.scene_instance.json", + "./4/ProcTHOR-Train-2726.scene_instance.json", + "./4/ProcTHOR-Train-2193.scene_instance.json", + "./4/ProcTHOR-Train-2992.scene_instance.json", + "./4/ProcTHOR-Train-2931.scene_instance.json", + "./4/ProcTHOR-Train-2889.scene_instance.json", + "./4/ProcTHOR-Train-2790.scene_instance.json", + "./4/ProcTHOR-Train-2488.scene_instance.json", + "./4/ProcTHOR-Train-2571.scene_instance.json", + "./4/ProcTHOR-Train-2032.scene_instance.json", + "./4/ProcTHOR-Train-2598.scene_instance.json", + "./4/ProcTHOR-Train-2019.scene_instance.json", + "./4/ProcTHOR-Train-2442.scene_instance.json", + "./4/ProcTHOR-Train-2303.scene_instance.json", + "./4/ProcTHOR-Train-2678.scene_instance.json", + "./4/ProcTHOR-Train-2397.scene_instance.json", + "./4/ProcTHOR-Train-2214.scene_instance.json", + "./4/ProcTHOR-Train-2395.scene_instance.json", + "./4/ProcTHOR-Train-2450.scene_instance.json", + "./4/ProcTHOR-Train-2210.scene_instance.json", + "./4/ProcTHOR-Train-2343.scene_instance.json", + "./4/ProcTHOR-Train-2354.scene_instance.json", + "./4/ProcTHOR-Train-2757.scene_instance.json", + "./4/ProcTHOR-Train-2322.scene_instance.json", + "./4/ProcTHOR-Train-2596.scene_instance.json", + "./4/ProcTHOR-Train-2788.scene_instance.json", + "./4/ProcTHOR-Train-2454.scene_instance.json", + "./4/ProcTHOR-Train-2380.scene_instance.json", + "./4/ProcTHOR-Train-2477.scene_instance.json", + "./4/ProcTHOR-Train-2374.scene_instance.json", + "./4/ProcTHOR-Train-2335.scene_instance.json", + "./4/ProcTHOR-Train-2010.scene_instance.json", + "./4/ProcTHOR-Train-2818.scene_instance.json", + "./4/ProcTHOR-Train-2178.scene_instance.json", + "./4/ProcTHOR-Train-2746.scene_instance.json", + "./4/ProcTHOR-Train-2588.scene_instance.json", + "./4/ProcTHOR-Train-2304.scene_instance.json", + "./4/ProcTHOR-Train-2546.scene_instance.json", + "./4/ProcTHOR-Train-2219.scene_instance.json", + "./4/ProcTHOR-Train-2911.scene_instance.json", + "./4/ProcTHOR-Train-2782.scene_instance.json", + "./4/ProcTHOR-Train-2586.scene_instance.json", + "./4/ProcTHOR-Train-2308.scene_instance.json", + "./4/ProcTHOR-Train-2463.scene_instance.json", + "./4/ProcTHOR-Train-2315.scene_instance.json", + "./4/ProcTHOR-Train-2068.scene_instance.json", + "./4/ProcTHOR-Train-2030.scene_instance.json", + "./4/ProcTHOR-Train-2280.scene_instance.json", + "./4/ProcTHOR-Train-2560.scene_instance.json", + "./4/ProcTHOR-Train-2706.scene_instance.json", + "./4/ProcTHOR-Train-2742.scene_instance.json", + "./4/ProcTHOR-Train-2087.scene_instance.json", + "./4/ProcTHOR-Train-2585.scene_instance.json", + "./4/ProcTHOR-Train-2057.scene_instance.json", + "./4/ProcTHOR-Train-2802.scene_instance.json", + "./4/ProcTHOR-Train-2184.scene_instance.json", + "./4/ProcTHOR-Train-2982.scene_instance.json", + "./4/ProcTHOR-Train-2027.scene_instance.json", + "./4/ProcTHOR-Train-2176.scene_instance.json", + "./4/ProcTHOR-Train-2065.scene_instance.json", + "./4/ProcTHOR-Train-2186.scene_instance.json", + "./4/ProcTHOR-Train-2400.scene_instance.json", + "./4/ProcTHOR-Train-2549.scene_instance.json", + "./4/ProcTHOR-Train-2981.scene_instance.json", + "./4/ProcTHOR-Train-2514.scene_instance.json", + "./4/ProcTHOR-Train-2950.scene_instance.json", + "./4/ProcTHOR-Train-2887.scene_instance.json", + "./4/ProcTHOR-Train-2016.scene_instance.json", + "./4/ProcTHOR-Train-2383.scene_instance.json", + "./4/ProcTHOR-Train-2961.scene_instance.json", + "./4/ProcTHOR-Train-2266.scene_instance.json", + "./4/ProcTHOR-Train-2963.scene_instance.json", + "./4/ProcTHOR-Train-2937.scene_instance.json", + "./4/ProcTHOR-Train-2791.scene_instance.json", + "./4/ProcTHOR-Train-2855.scene_instance.json", + "./4/ProcTHOR-Train-2612.scene_instance.json", + "./4/ProcTHOR-Train-2350.scene_instance.json", + "./4/ProcTHOR-Train-2117.scene_instance.json", + "./4/ProcTHOR-Train-2715.scene_instance.json", + "./4/ProcTHOR-Train-2970.scene_instance.json", + "./4/ProcTHOR-Train-2203.scene_instance.json", + "./4/ProcTHOR-Train-2601.scene_instance.json", + "./4/ProcTHOR-Train-2036.scene_instance.json", + "./4/ProcTHOR-Train-2194.scene_instance.json", + "./4/ProcTHOR-Train-2301.scene_instance.json", + "./4/ProcTHOR-Train-2410.scene_instance.json", + "./4/ProcTHOR-Train-2783.scene_instance.json", + "./4/ProcTHOR-Train-2543.scene_instance.json", + "./4/ProcTHOR-Train-2102.scene_instance.json", + "./4/ProcTHOR-Train-2448.scene_instance.json", + "./4/ProcTHOR-Train-2003.scene_instance.json", + "./4/ProcTHOR-Train-2501.scene_instance.json", + "./4/ProcTHOR-Train-2429.scene_instance.json", + "./4/ProcTHOR-Train-2823.scene_instance.json", + "./4/ProcTHOR-Train-2990.scene_instance.json", + "./4/ProcTHOR-Train-2145.scene_instance.json", + "./4/ProcTHOR-Train-2523.scene_instance.json", + "./4/ProcTHOR-Train-2101.scene_instance.json", + "./4/ProcTHOR-Train-2985.scene_instance.json", + "./4/ProcTHOR-Train-2693.scene_instance.json", + "./4/ProcTHOR-Train-2162.scene_instance.json", + "./4/ProcTHOR-Train-2936.scene_instance.json", + "./4/ProcTHOR-Train-2384.scene_instance.json", + "./4/ProcTHOR-Train-2006.scene_instance.json", + "./4/ProcTHOR-Train-2470.scene_instance.json", + "./4/ProcTHOR-Train-2028.scene_instance.json", + "./4/ProcTHOR-Train-2403.scene_instance.json", + "./4/ProcTHOR-Train-2608.scene_instance.json", + "./4/ProcTHOR-Train-2126.scene_instance.json", + "./4/ProcTHOR-Train-2382.scene_instance.json", + "./4/ProcTHOR-Train-2440.scene_instance.json", + "./4/ProcTHOR-Train-2252.scene_instance.json", + "./4/ProcTHOR-Train-2125.scene_instance.json", + "./4/ProcTHOR-Train-2260.scene_instance.json", + "./4/ProcTHOR-Train-2371.scene_instance.json", + "./4/ProcTHOR-Train-2498.scene_instance.json", + "./4/ProcTHOR-Train-2733.scene_instance.json", + "./4/ProcTHOR-Train-2659.scene_instance.json", + "./4/ProcTHOR-Train-2296.scene_instance.json", + "./4/ProcTHOR-Train-2008.scene_instance.json", + "./4/ProcTHOR-Train-2934.scene_instance.json", + "./4/ProcTHOR-Train-2033.scene_instance.json", + "./4/ProcTHOR-Train-2555.scene_instance.json", + "./4/ProcTHOR-Train-2326.scene_instance.json", + "./4/ProcTHOR-Train-2647.scene_instance.json", + "./4/ProcTHOR-Train-2595.scene_instance.json", + "./4/ProcTHOR-Train-2097.scene_instance.json", + "./4/ProcTHOR-Train-2635.scene_instance.json", + "./4/ProcTHOR-Train-2738.scene_instance.json", + "./4/ProcTHOR-Train-2040.scene_instance.json", + "./4/ProcTHOR-Train-2729.scene_instance.json", + "./4/ProcTHOR-Train-2624.scene_instance.json", + "./4/ProcTHOR-Train-2775.scene_instance.json", + "./4/ProcTHOR-Train-2247.scene_instance.json", + "./4/ProcTHOR-Train-2151.scene_instance.json", + "./4/ProcTHOR-Train-2623.scene_instance.json", + "./4/ProcTHOR-Train-2421.scene_instance.json", + "./4/ProcTHOR-Train-2877.scene_instance.json", + "./4/ProcTHOR-Train-2452.scene_instance.json", + "./4/ProcTHOR-Train-2173.scene_instance.json", + "./4/ProcTHOR-Train-2968.scene_instance.json", + "./4/ProcTHOR-Train-2221.scene_instance.json", + "./4/ProcTHOR-Train-2566.scene_instance.json", + "./4/ProcTHOR-Train-2701.scene_instance.json", + "./4/ProcTHOR-Train-2704.scene_instance.json", + "./4/ProcTHOR-Train-2324.scene_instance.json", + "./4/ProcTHOR-Train-2996.scene_instance.json", + "./4/ProcTHOR-Train-2567.scene_instance.json", + "./4/ProcTHOR-Train-2739.scene_instance.json", + "./4/ProcTHOR-Train-2484.scene_instance.json", + "./4/ProcTHOR-Train-2289.scene_instance.json", + "./4/ProcTHOR-Train-2650.scene_instance.json", + "./4/ProcTHOR-Train-2884.scene_instance.json", + "./4/ProcTHOR-Train-2854.scene_instance.json", + "./4/ProcTHOR-Train-2271.scene_instance.json", + "./4/ProcTHOR-Train-2142.scene_instance.json", + "./4/ProcTHOR-Train-2881.scene_instance.json", + "./4/ProcTHOR-Train-2801.scene_instance.json", + "./4/ProcTHOR-Train-2610.scene_instance.json", + "./4/ProcTHOR-Train-2123.scene_instance.json", + "./4/ProcTHOR-Train-2525.scene_instance.json", + "./4/ProcTHOR-Train-2979.scene_instance.json", + "./4/ProcTHOR-Train-2340.scene_instance.json", + "./4/ProcTHOR-Train-2359.scene_instance.json", + "./4/ProcTHOR-Train-2047.scene_instance.json", + "./4/ProcTHOR-Train-2431.scene_instance.json", + "./4/ProcTHOR-Train-2957.scene_instance.json", + "./4/ProcTHOR-Train-2281.scene_instance.json", + "./4/ProcTHOR-Train-2021.scene_instance.json", + "./4/ProcTHOR-Train-2866.scene_instance.json", + "./4/ProcTHOR-Train-2376.scene_instance.json", + "./4/ProcTHOR-Train-2520.scene_instance.json", + "./4/ProcTHOR-Train-2256.scene_instance.json", + "./4/ProcTHOR-Train-2872.scene_instance.json", + "./4/ProcTHOR-Train-2544.scene_instance.json", + "./4/ProcTHOR-Train-2265.scene_instance.json", + "./4/ProcTHOR-Train-2695.scene_instance.json", + "./4/ProcTHOR-Train-2882.scene_instance.json", + "./4/ProcTHOR-Train-2770.scene_instance.json", + "./4/ProcTHOR-Train-2052.scene_instance.json", + "./4/ProcTHOR-Train-2504.scene_instance.json", + "./4/ProcTHOR-Train-2263.scene_instance.json", + "./4/ProcTHOR-Train-2253.scene_instance.json", + "./4/ProcTHOR-Train-2512.scene_instance.json", + "./4/ProcTHOR-Train-2894.scene_instance.json", + "./4/ProcTHOR-Train-2786.scene_instance.json", + "./4/ProcTHOR-Train-2078.scene_instance.json", + "./4/ProcTHOR-Train-2011.scene_instance.json", + "./4/ProcTHOR-Train-2928.scene_instance.json", + "./4/ProcTHOR-Train-2238.scene_instance.json", + "./4/ProcTHOR-Train-2163.scene_instance.json", + "./4/ProcTHOR-Train-2912.scene_instance.json", + "./4/ProcTHOR-Train-2831.scene_instance.json", + "./4/ProcTHOR-Train-2740.scene_instance.json", + "./4/ProcTHOR-Train-2870.scene_instance.json", + "./4/ProcTHOR-Train-2977.scene_instance.json", + "./4/ProcTHOR-Train-2360.scene_instance.json", + "./4/ProcTHOR-Train-2422.scene_instance.json", + "./4/ProcTHOR-Train-2932.scene_instance.json", + "./4/ProcTHOR-Train-2451.scene_instance.json", + "./4/ProcTHOR-Train-2328.scene_instance.json", + "./4/ProcTHOR-Train-2824.scene_instance.json", + "./4/ProcTHOR-Train-2205.scene_instance.json", + "./4/ProcTHOR-Train-2111.scene_instance.json", + "./4/ProcTHOR-Train-2200.scene_instance.json", + "./4/ProcTHOR-Train-2534.scene_instance.json", + "./4/ProcTHOR-Train-2841.scene_instance.json", + "./4/ProcTHOR-Train-2940.scene_instance.json", + "./4/ProcTHOR-Train-2798.scene_instance.json", + "./4/ProcTHOR-Train-2345.scene_instance.json", + "./4/ProcTHOR-Train-2552.scene_instance.json", + "./4/ProcTHOR-Train-2597.scene_instance.json", + "./4/ProcTHOR-Train-2095.scene_instance.json", + "./4/ProcTHOR-Train-2279.scene_instance.json", + "./4/ProcTHOR-Train-2150.scene_instance.json", + "./4/ProcTHOR-Train-2015.scene_instance.json", + "./4/ProcTHOR-Train-2213.scene_instance.json", + "./4/ProcTHOR-Train-2749.scene_instance.json", + "./4/ProcTHOR-Train-2976.scene_instance.json", + "./4/ProcTHOR-Train-2538.scene_instance.json", + "./4/ProcTHOR-Train-2489.scene_instance.json", + "./4/ProcTHOR-Train-2277.scene_instance.json", + "./4/ProcTHOR-Train-2396.scene_instance.json", + "./4/ProcTHOR-Train-2147.scene_instance.json", + "./4/ProcTHOR-Train-2811.scene_instance.json", + "./4/ProcTHOR-Train-2248.scene_instance.json", + "./4/ProcTHOR-Train-2743.scene_instance.json", + "./4/ProcTHOR-Train-2467.scene_instance.json", + "./4/ProcTHOR-Train-2373.scene_instance.json", + "./4/ProcTHOR-Train-2120.scene_instance.json", + "./4/ProcTHOR-Train-2130.scene_instance.json", + "./4/ProcTHOR-Train-2211.scene_instance.json", + "./4/ProcTHOR-Train-2584.scene_instance.json", + "./4/ProcTHOR-Train-2863.scene_instance.json", + "./4/ProcTHOR-Train-2974.scene_instance.json", + "./4/ProcTHOR-Train-2653.scene_instance.json", + "./4/ProcTHOR-Train-2554.scene_instance.json", + "./4/ProcTHOR-Train-2417.scene_instance.json", + "./4/ProcTHOR-Train-2787.scene_instance.json", + "./4/ProcTHOR-Train-2614.scene_instance.json", + "./4/ProcTHOR-Train-2004.scene_instance.json", + "./4/ProcTHOR-Train-2709.scene_instance.json", + "./4/ProcTHOR-Train-2998.scene_instance.json", + "./4/ProcTHOR-Train-2288.scene_instance.json", + "./4/ProcTHOR-Train-2975.scene_instance.json", + "./4/ProcTHOR-Train-2079.scene_instance.json", + "./4/ProcTHOR-Train-2494.scene_instance.json", + "./4/ProcTHOR-Train-2922.scene_instance.json", + "./4/ProcTHOR-Train-2828.scene_instance.json", + "./4/ProcTHOR-Train-2370.scene_instance.json", + "./4/ProcTHOR-Train-2055.scene_instance.json", + "./4/ProcTHOR-Train-2310.scene_instance.json", + "./4/ProcTHOR-Train-2272.scene_instance.json", + "./4/ProcTHOR-Train-2446.scene_instance.json", + "./4/ProcTHOR-Train-2492.scene_instance.json", + "./4/ProcTHOR-Train-2246.scene_instance.json", + "./4/ProcTHOR-Train-2927.scene_instance.json", + "./4/ProcTHOR-Train-2105.scene_instance.json", + "./4/ProcTHOR-Train-2215.scene_instance.json", + "./4/ProcTHOR-Train-2913.scene_instance.json", + "./4/ProcTHOR-Train-2756.scene_instance.json", + "./4/ProcTHOR-Train-2258.scene_instance.json", + "./4/ProcTHOR-Train-2772.scene_instance.json", + "./4/ProcTHOR-Train-2432.scene_instance.json", + "./4/ProcTHOR-Train-2327.scene_instance.json", + "./4/ProcTHOR-Train-2118.scene_instance.json", + "./4/ProcTHOR-Train-2390.scene_instance.json", + "./4/ProcTHOR-Train-2581.scene_instance.json", + "./4/ProcTHOR-Train-2773.scene_instance.json", + "./4/ProcTHOR-Train-2284.scene_instance.json", + "./4/ProcTHOR-Train-2812.scene_instance.json", + "./4/ProcTHOR-Train-2621.scene_instance.json", + "./4/ProcTHOR-Train-2115.scene_instance.json", + "./4/ProcTHOR-Train-2892.scene_instance.json", + "./4/ProcTHOR-Train-2618.scene_instance.json", + "./4/ProcTHOR-Train-2192.scene_instance.json", + "./4/ProcTHOR-Train-2687.scene_instance.json", + "./4/ProcTHOR-Train-2433.scene_instance.json", + "./4/ProcTHOR-Train-2833.scene_instance.json", + "./4/ProcTHOR-Train-2168.scene_instance.json", + "./4/ProcTHOR-Train-2837.scene_instance.json", + "./4/ProcTHOR-Train-2083.scene_instance.json", + "./4/ProcTHOR-Train-2113.scene_instance.json", + "./4/ProcTHOR-Train-2502.scene_instance.json", + "./4/ProcTHOR-Train-2730.scene_instance.json", + "./4/ProcTHOR-Train-2897.scene_instance.json", + "./4/ProcTHOR-Train-2734.scene_instance.json", + "./4/ProcTHOR-Train-2827.scene_instance.json", + "./4/ProcTHOR-Train-2269.scene_instance.json", + "./4/ProcTHOR-Train-2652.scene_instance.json", + "./4/ProcTHOR-Train-2195.scene_instance.json", + "./4/ProcTHOR-Train-2462.scene_instance.json", + "./4/ProcTHOR-Train-2416.scene_instance.json", + "./4/ProcTHOR-Train-2031.scene_instance.json", + "./4/ProcTHOR-Train-2236.scene_instance.json", + "./4/ProcTHOR-Train-2414.scene_instance.json", + "./4/ProcTHOR-Train-2681.scene_instance.json", + "./4/ProcTHOR-Train-2116.scene_instance.json", + "./4/ProcTHOR-Train-2387.scene_instance.json", + "./4/ProcTHOR-Train-2574.scene_instance.json", + "./4/ProcTHOR-Train-2737.scene_instance.json", + "./4/ProcTHOR-Train-2952.scene_instance.json", + "./4/ProcTHOR-Train-2369.scene_instance.json", + "./4/ProcTHOR-Train-2051.scene_instance.json", + "./4/ProcTHOR-Train-2255.scene_instance.json", + "./4/ProcTHOR-Train-2971.scene_instance.json", + "./4/ProcTHOR-Train-2691.scene_instance.json", + "./4/ProcTHOR-Train-2697.scene_instance.json", + "./4/ProcTHOR-Train-2626.scene_instance.json", + "./4/ProcTHOR-Train-2167.scene_instance.json", + "./4/ProcTHOR-Train-2165.scene_instance.json", + "./4/ProcTHOR-Train-2563.scene_instance.json", + "./4/ProcTHOR-Train-2510.scene_instance.json", + "./4/ProcTHOR-Train-2664.scene_instance.json", + "./4/ProcTHOR-Train-2649.scene_instance.json", + "./4/ProcTHOR-Train-2112.scene_instance.json", + "./4/ProcTHOR-Train-2420.scene_instance.json", + "./4/ProcTHOR-Train-2616.scene_instance.json", + "./4/ProcTHOR-Train-2893.scene_instance.json", + "./4/ProcTHOR-Train-2657.scene_instance.json", + "./4/ProcTHOR-Train-2761.scene_instance.json", + "./4/ProcTHOR-Train-2880.scene_instance.json", + "./4/ProcTHOR-Train-2530.scene_instance.json", + "./4/ProcTHOR-Train-2899.scene_instance.json", + "./4/ProcTHOR-Train-2505.scene_instance.json", + "./4/ProcTHOR-Train-2388.scene_instance.json", + "./4/ProcTHOR-Train-2903.scene_instance.json", + "./4/ProcTHOR-Train-2923.scene_instance.json", + "./4/ProcTHOR-Train-2319.scene_instance.json", + "./4/ProcTHOR-Train-2394.scene_instance.json", + "./4/ProcTHOR-Train-2984.scene_instance.json", + "./4/ProcTHOR-Train-2368.scene_instance.json", + "./4/ProcTHOR-Train-2482.scene_instance.json", + "./4/ProcTHOR-Train-2307.scene_instance.json", + "./4/ProcTHOR-Train-2358.scene_instance.json", + "./4/ProcTHOR-Train-2999.scene_instance.json", + "./4/ProcTHOR-Train-2924.scene_instance.json", + "./4/ProcTHOR-Train-2274.scene_instance.json", + "./4/ProcTHOR-Train-2862.scene_instance.json", + "./4/ProcTHOR-Train-2660.scene_instance.json", + "./4/ProcTHOR-Train-2690.scene_instance.json", + "./4/ProcTHOR-Train-2183.scene_instance.json", + "./4/ProcTHOR-Train-2685.scene_instance.json", + "./4/ProcTHOR-Train-2249.scene_instance.json", + "./4/ProcTHOR-Train-2149.scene_instance.json", + "./4/ProcTHOR-Train-2763.scene_instance.json", + "./4/ProcTHOR-Train-2600.scene_instance.json", + "./4/ProcTHOR-Train-2212.scene_instance.json", + "./4/ProcTHOR-Train-2314.scene_instance.json", + "./4/ProcTHOR-Train-2472.scene_instance.json", + "./4/ProcTHOR-Train-2172.scene_instance.json", + "./4/ProcTHOR-Train-2259.scene_instance.json", + "./4/ProcTHOR-Train-2411.scene_instance.json", + "./4/ProcTHOR-Train-2707.scene_instance.json", + "./4/ProcTHOR-Train-2758.scene_instance.json", + "./4/ProcTHOR-Train-2351.scene_instance.json", + "./4/ProcTHOR-Train-2235.scene_instance.json", + "./4/ProcTHOR-Train-2207.scene_instance.json", + "./4/ProcTHOR-Train-2702.scene_instance.json", + "./4/ProcTHOR-Train-2043.scene_instance.json", + "./4/ProcTHOR-Train-2741.scene_instance.json", + "./4/ProcTHOR-Train-2513.scene_instance.json", + "./4/ProcTHOR-Train-2485.scene_instance.json", + "./4/ProcTHOR-Train-2077.scene_instance.json", + "./4/ProcTHOR-Train-2337.scene_instance.json", + "./4/ProcTHOR-Train-2888.scene_instance.json", + "./4/ProcTHOR-Train-2075.scene_instance.json", + "./4/ProcTHOR-Train-2318.scene_instance.json", + "./4/ProcTHOR-Train-2218.scene_instance.json", + "./4/ProcTHOR-Train-2460.scene_instance.json", + "./4/ProcTHOR-Train-2873.scene_instance.json", + "./4/ProcTHOR-Train-2522.scene_instance.json", + "./4/ProcTHOR-Train-2508.scene_instance.json", + "./4/ProcTHOR-Train-2441.scene_instance.json", + "./4/ProcTHOR-Train-2550.scene_instance.json", + "./4/ProcTHOR-Train-2677.scene_instance.json", + "./4/ProcTHOR-Train-2175.scene_instance.json", + "./4/ProcTHOR-Train-2651.scene_instance.json", + "./4/ProcTHOR-Train-2898.scene_instance.json", + "./4/ProcTHOR-Train-2956.scene_instance.json", + "./4/ProcTHOR-Train-2803.scene_instance.json", + "./4/ProcTHOR-Train-2980.scene_instance.json", + "./4/ProcTHOR-Train-2774.scene_instance.json", + "./4/ProcTHOR-Train-2632.scene_instance.json", + "./4/ProcTHOR-Train-2049.scene_instance.json", + "./4/ProcTHOR-Train-2539.scene_instance.json", + "./4/ProcTHOR-Train-2121.scene_instance.json", + "./4/ProcTHOR-Train-2353.scene_instance.json", + "./4/ProcTHOR-Train-2261.scene_instance.json", + "./4/ProcTHOR-Train-2223.scene_instance.json", + "./4/ProcTHOR-Train-2103.scene_instance.json", + "./4/ProcTHOR-Train-2810.scene_instance.json", + "./4/ProcTHOR-Train-2777.scene_instance.json", + "./4/ProcTHOR-Train-2169.scene_instance.json", + "./4/ProcTHOR-Train-2955.scene_instance.json", + "./4/ProcTHOR-Train-2949.scene_instance.json", + "./4/ProcTHOR-Train-2332.scene_instance.json", + "./4/ProcTHOR-Train-2056.scene_instance.json", + "./4/ProcTHOR-Train-2945.scene_instance.json", + "./4/ProcTHOR-Train-2298.scene_instance.json", + "./4/ProcTHOR-Train-2104.scene_instance.json", + "./4/ProcTHOR-Train-2732.scene_instance.json", + "./4/ProcTHOR-Train-2425.scene_instance.json", + "./4/ProcTHOR-Train-2048.scene_instance.json", + "./4/ProcTHOR-Train-2675.scene_instance.json", + "./4/ProcTHOR-Train-2938.scene_instance.json", + "./4/ProcTHOR-Train-2320.scene_instance.json", + "./4/ProcTHOR-Train-2719.scene_instance.json", + "./4/ProcTHOR-Train-2930.scene_instance.json", + "./4/ProcTHOR-Train-2088.scene_instance.json", + "./4/ProcTHOR-Train-2901.scene_instance.json", + "./4/ProcTHOR-Train-2106.scene_instance.json", + "./4/ProcTHOR-Train-2991.scene_instance.json", + "./4/ProcTHOR-Train-2225.scene_instance.json", + "./4/ProcTHOR-Train-2499.scene_instance.json", + "./4/ProcTHOR-Train-2752.scene_instance.json", + "./4/ProcTHOR-Train-2137.scene_instance.json", + "./4/ProcTHOR-Train-2541.scene_instance.json", + "./4/ProcTHOR-Train-2229.scene_instance.json", + "./4/ProcTHOR-Train-2391.scene_instance.json", + "./4/ProcTHOR-Train-2948.scene_instance.json", + "./4/ProcTHOR-Train-2413.scene_instance.json", + "./4/ProcTHOR-Train-2806.scene_instance.json", + "./4/ProcTHOR-Train-2785.scene_instance.json", + "./4/ProcTHOR-Train-2385.scene_instance.json", + "./4/ProcTHOR-Train-2755.scene_instance.json", + "./4/ProcTHOR-Train-2230.scene_instance.json", + "./4/ProcTHOR-Train-2986.scene_instance.json", + "./4/ProcTHOR-Train-2638.scene_instance.json", + "./4/ProcTHOR-Train-2735.scene_instance.json", + "./4/ProcTHOR-Train-2185.scene_instance.json", + "./4/ProcTHOR-Train-2180.scene_instance.json", + "./4/ProcTHOR-Train-2793.scene_instance.json", + "./4/ProcTHOR-Train-2132.scene_instance.json", + "./4/ProcTHOR-Train-2299.scene_instance.json", + "./4/ProcTHOR-Train-2939.scene_instance.json", + "./4/ProcTHOR-Train-2234.scene_instance.json", + "./4/ProcTHOR-Train-2478.scene_instance.json", + "./4/ProcTHOR-Train-2804.scene_instance.json", + "./4/ProcTHOR-Train-2587.scene_instance.json", + "./4/ProcTHOR-Train-2871.scene_instance.json", + "./4/ProcTHOR-Train-2426.scene_instance.json", + "./4/ProcTHOR-Train-2717.scene_instance.json", + "./4/ProcTHOR-Train-2869.scene_instance.json", + "./4/ProcTHOR-Train-2378.scene_instance.json", + "./4/ProcTHOR-Train-2244.scene_instance.json", + "./4/ProcTHOR-Train-2129.scene_instance.json", + "./4/ProcTHOR-Train-2069.scene_instance.json", + "./4/ProcTHOR-Train-2060.scene_instance.json", + "./4/ProcTHOR-Train-2282.scene_instance.json", + "./4/ProcTHOR-Train-2363.scene_instance.json", + "./4/ProcTHOR-Train-2641.scene_instance.json", + "./4/ProcTHOR-Train-2293.scene_instance.json", + "./4/ProcTHOR-Train-2461.scene_instance.json", + "./4/ProcTHOR-Train-2883.scene_instance.json", + "./4/ProcTHOR-Train-2993.scene_instance.json", + "./4/ProcTHOR-Train-2852.scene_instance.json", + "./4/ProcTHOR-Train-2295.scene_instance.json", + "./4/ProcTHOR-Train-2366.scene_instance.json", + "./4/ProcTHOR-Train-2908.scene_instance.json", + "./4/ProcTHOR-Train-2160.scene_instance.json", + "./4/ProcTHOR-Train-2700.scene_instance.json", + "./4/ProcTHOR-Train-2910.scene_instance.json", + "./4/ProcTHOR-Train-2242.scene_instance.json", + "./4/ProcTHOR-Train-2058.scene_instance.json", + "./4/ProcTHOR-Train-2002.scene_instance.json", + "./4/ProcTHOR-Train-2909.scene_instance.json", + "./4/ProcTHOR-Train-2579.scene_instance.json", + "./4/ProcTHOR-Train-2521.scene_instance.json", + "./4/ProcTHOR-Train-2796.scene_instance.json", + "./4/ProcTHOR-Train-2589.scene_instance.json", + "./4/ProcTHOR-Train-2532.scene_instance.json", + "./4/ProcTHOR-Train-2159.scene_instance.json", + "./4/ProcTHOR-Train-2474.scene_instance.json", + "./4/ProcTHOR-Train-2876.scene_instance.json", + "./4/ProcTHOR-Train-2084.scene_instance.json", + "./4/ProcTHOR-Train-2712.scene_instance.json", + "./4/ProcTHOR-Train-2941.scene_instance.json", + "./4/ProcTHOR-Train-2526.scene_instance.json", + "./4/ProcTHOR-Train-2658.scene_instance.json", + "./4/ProcTHOR-Train-2842.scene_instance.json", + "./4/ProcTHOR-Train-2124.scene_instance.json", + "./4/ProcTHOR-Train-2438.scene_instance.json", + "./4/ProcTHOR-Train-2493.scene_instance.json", + "./4/ProcTHOR-Train-2859.scene_instance.json", + "./4/ProcTHOR-Train-2107.scene_instance.json", + "./4/ProcTHOR-Train-2352.scene_instance.json", + "./4/ProcTHOR-Train-2496.scene_instance.json", + "./4/ProcTHOR-Train-2436.scene_instance.json", + "./4/ProcTHOR-Train-2026.scene_instance.json", + "./4/ProcTHOR-Train-2286.scene_instance.json", + "./4/ProcTHOR-Train-2634.scene_instance.json", + "./4/ProcTHOR-Train-2415.scene_instance.json", + "./4/ProcTHOR-Train-2177.scene_instance.json", + "./4/ProcTHOR-Train-2885.scene_instance.json", + "./4/ProcTHOR-Train-2847.scene_instance.json", + "./4/ProcTHOR-Train-2944.scene_instance.json", + "./4/ProcTHOR-Train-2760.scene_instance.json", + "./4/ProcTHOR-Train-2846.scene_instance.json", + "./4/ProcTHOR-Train-2988.scene_instance.json", + "./4/ProcTHOR-Train-2361.scene_instance.json", + "./4/ProcTHOR-Train-2711.scene_instance.json", + "./4/ProcTHOR-Train-2684.scene_instance.json", + "./4/ProcTHOR-Train-2216.scene_instance.json", + "./4/ProcTHOR-Train-2182.scene_instance.json", + "./4/ProcTHOR-Train-2418.scene_instance.json", + "./4/ProcTHOR-Train-2698.scene_instance.json", + "./4/ProcTHOR-Train-2670.scene_instance.json", + "./4/ProcTHOR-Train-2764.scene_instance.json", + "./4/ProcTHOR-Train-2399.scene_instance.json", + "./4/ProcTHOR-Train-2076.scene_instance.json", + "./4/ProcTHOR-Train-2141.scene_instance.json", + "./4/ProcTHOR-Train-2468.scene_instance.json", + "./4/ProcTHOR-Train-2228.scene_instance.json", + "./4/ProcTHOR-Train-2241.scene_instance.json", + "./4/ProcTHOR-Train-2243.scene_instance.json", + "./4/ProcTHOR-Train-2680.scene_instance.json", + "./4/ProcTHOR-Train-2401.scene_instance.json", + "./4/ProcTHOR-Train-2067.scene_instance.json", + "./4/ProcTHOR-Train-2814.scene_instance.json", + "./4/ProcTHOR-Train-2832.scene_instance.json", + "./4/ProcTHOR-Train-2865.scene_instance.json", + "./4/ProcTHOR-Train-2611.scene_instance.json", + "./4/ProcTHOR-Train-2300.scene_instance.json", + "./4/ProcTHOR-Train-2914.scene_instance.json", + "./4/ProcTHOR-Train-2199.scene_instance.json", + "./4/ProcTHOR-Train-2153.scene_instance.json", + "./4/ProcTHOR-Train-2682.scene_instance.json", + "./4/ProcTHOR-Train-2444.scene_instance.json", + "./4/ProcTHOR-Train-2237.scene_instance.json", + "./4/ProcTHOR-Train-2196.scene_instance.json", + "./4/ProcTHOR-Train-2724.scene_instance.json", + "./4/ProcTHOR-Train-2874.scene_instance.json", + "./4/ProcTHOR-Train-2605.scene_instance.json", + "./4/ProcTHOR-Train-2954.scene_instance.json", + "./4/ProcTHOR-Train-2578.scene_instance.json", + "./4/ProcTHOR-Train-2528.scene_instance.json", + "./4/ProcTHOR-Train-2270.scene_instance.json", + "./4/ProcTHOR-Train-2439.scene_instance.json", + "./4/ProcTHOR-Train-2703.scene_instance.json", + "./4/ProcTHOR-Train-2486.scene_instance.json", + "./4/ProcTHOR-Train-2705.scene_instance.json", + "./4/ProcTHOR-Train-2559.scene_instance.json", + "./4/ProcTHOR-Train-2838.scene_instance.json", + "./4/ProcTHOR-Train-2556.scene_instance.json", + "./4/ProcTHOR-Train-2133.scene_instance.json", + "./4/ProcTHOR-Train-2868.scene_instance.json", + "./4/ProcTHOR-Train-2577.scene_instance.json", + "./4/ProcTHOR-Train-2669.scene_instance.json", + "./4/ProcTHOR-Train-2491.scene_instance.json", + "./4/ProcTHOR-Train-2807.scene_instance.json", + "./4/ProcTHOR-Train-2799.scene_instance.json", + "./4/ProcTHOR-Train-2154.scene_instance.json", + "./4/ProcTHOR-Train-2978.scene_instance.json", + "./4/ProcTHOR-Train-2805.scene_instance.json", + "./4/ProcTHOR-Train-2458.scene_instance.json", + "./4/ProcTHOR-Train-2750.scene_instance.json", + "./4/ProcTHOR-Train-2830.scene_instance.json", + "./4/ProcTHOR-Train-2694.scene_instance.json", + "./4/ProcTHOR-Train-2503.scene_instance.json", + "./4/ProcTHOR-Train-2642.scene_instance.json", + "./4/ProcTHOR-Train-2037.scene_instance.json", + "./4/ProcTHOR-Train-2459.scene_instance.json", + "./4/ProcTHOR-Train-2233.scene_instance.json", + "./4/ProcTHOR-Train-2506.scene_instance.json", + "./4/ProcTHOR-Train-2321.scene_instance.json", + "./4/ProcTHOR-Train-2710.scene_instance.json", + "./4/ProcTHOR-Train-2316.scene_instance.json", + "./4/ProcTHOR-Train-2059.scene_instance.json", + "./4/ProcTHOR-Train-2041.scene_instance.json", + "./4/ProcTHOR-Train-2808.scene_instance.json", + "./4/ProcTHOR-Train-2619.scene_instance.json", + "./4/ProcTHOR-Train-2025.scene_instance.json", + "./4/ProcTHOR-Train-2355.scene_instance.json", + "./4/ProcTHOR-Train-2294.scene_instance.json", + "./4/ProcTHOR-Train-2357.scene_instance.json", + "./4/ProcTHOR-Train-2365.scene_instance.json", + "./4/ProcTHOR-Train-2569.scene_instance.json", + "./4/ProcTHOR-Train-2251.scene_instance.json", + "./4/ProcTHOR-Train-2576.scene_instance.json", + "./4/ProcTHOR-Train-2424.scene_instance.json", + "./4/ProcTHOR-Train-2848.scene_instance.json", + "./4/ProcTHOR-Train-2283.scene_instance.json", + "./4/ProcTHOR-Train-2257.scene_instance.json", + "./4/ProcTHOR-Train-2648.scene_instance.json", + "./4/ProcTHOR-Train-2392.scene_instance.json", + "./4/ProcTHOR-Train-2062.scene_instance.json", + "./4/ProcTHOR-Train-2617.scene_instance.json", + "./4/ProcTHOR-Train-2781.scene_instance.json", + "./4/ProcTHOR-Train-2437.scene_instance.json", + "./4/ProcTHOR-Train-2933.scene_instance.json", + "./4/ProcTHOR-Train-2629.scene_instance.json", + "./4/ProcTHOR-Train-2507.scene_instance.json", + "./4/ProcTHOR-Train-2305.scene_instance.json", + "./4/ProcTHOR-Train-2093.scene_instance.json", + "./4/ProcTHOR-Train-2285.scene_instance.json", + "./4/ProcTHOR-Train-2958.scene_instance.json", + "./4/ProcTHOR-Train-2907.scene_instance.json", + "./4/ProcTHOR-Train-2524.scene_instance.json", + "./4/ProcTHOR-Train-2780.scene_instance.json", + "./4/ProcTHOR-Train-2291.scene_instance.json", + "./4/ProcTHOR-Train-2393.scene_instance.json", + "./4/ProcTHOR-Train-2227.scene_instance.json", + "./4/ProcTHOR-Train-2329.scene_instance.json", + "./4/ProcTHOR-Train-2916.scene_instance.json", + "./4/ProcTHOR-Train-2071.scene_instance.json", + "./4/ProcTHOR-Train-2323.scene_instance.json", + "./4/ProcTHOR-Train-2561.scene_instance.json", + "./4/ProcTHOR-Train-2190.scene_instance.json", + "./4/ProcTHOR-Train-2108.scene_instance.json", + "./4/ProcTHOR-Train-2622.scene_instance.json", + "./4/ProcTHOR-Train-2134.scene_instance.json", + "./4/ProcTHOR-Train-2042.scene_instance.json", + "./4/ProcTHOR-Train-2152.scene_instance.json", + "./4/ProcTHOR-Train-2686.scene_instance.json", + "./4/ProcTHOR-Train-2663.scene_instance.json", + "./4/ProcTHOR-Train-2262.scene_instance.json", + "./4/ProcTHOR-Train-2779.scene_instance.json", + "./4/ProcTHOR-Train-2816.scene_instance.json", + "./4/ProcTHOR-Train-2918.scene_instance.json", + "./4/ProcTHOR-Train-2188.scene_instance.json", + "./4/ProcTHOR-Train-2671.scene_instance.json", + "./4/ProcTHOR-Train-2753.scene_instance.json", + "./4/ProcTHOR-Train-2465.scene_instance.json", + "./4/ProcTHOR-Train-2050.scene_instance.json", + "./4/ProcTHOR-Train-2408.scene_instance.json", + "./4/ProcTHOR-Train-2565.scene_instance.json", + "./4/ProcTHOR-Train-2198.scene_instance.json", + "./4/ProcTHOR-Train-2148.scene_instance.json", + "./4/ProcTHOR-Train-2633.scene_instance.json", + "./4/ProcTHOR-Train-2989.scene_instance.json", + "./4/ProcTHOR-Train-2926.scene_instance.json", + "./4/ProcTHOR-Train-2066.scene_instance.json", + "./4/ProcTHOR-Train-2665.scene_instance.json", + "./4/ProcTHOR-Train-2427.scene_instance.json", + "./4/ProcTHOR-Train-2725.scene_instance.json", + "./4/ProcTHOR-Train-2896.scene_instance.json", + "./4/ProcTHOR-Train-2603.scene_instance.json", + "./4/ProcTHOR-Train-2748.scene_instance.json", + "./4/ProcTHOR-Train-2966.scene_instance.json", + "./4/ProcTHOR-Train-2915.scene_instance.json", + "./4/ProcTHOR-Train-2404.scene_instance.json", + "./4/ProcTHOR-Train-2231.scene_instance.json", + "./4/ProcTHOR-Train-2825.scene_instance.json", + "./4/ProcTHOR-Train-2636.scene_instance.json", + "./4/ProcTHOR-Train-2080.scene_instance.json", + "./4/ProcTHOR-Train-2666.scene_instance.json", + "./4/ProcTHOR-Train-2389.scene_instance.json", + "./4/ProcTHOR-Train-2174.scene_instance.json", + "./4/ProcTHOR-Train-2714.scene_instance.json", + "./4/ProcTHOR-Train-2573.scene_instance.json", + "./4/ProcTHOR-Train-2946.scene_instance.json", + "./4/ProcTHOR-Train-2839.scene_instance.json", + "./4/ProcTHOR-Train-2900.scene_instance.json", + "./4/ProcTHOR-Train-2297.scene_instance.json", + "./4/ProcTHOR-Train-2330.scene_instance.json", + "./4/ProcTHOR-Train-2254.scene_instance.json", + "./4/ProcTHOR-Train-2951.scene_instance.json", + "./4/ProcTHOR-Train-2497.scene_instance.json", + "./4/ProcTHOR-Train-2039.scene_instance.json", + "./4/ProcTHOR-Train-2857.scene_instance.json", + "./4/ProcTHOR-Train-2208.scene_instance.json", + "./4/ProcTHOR-Train-2325.scene_instance.json", + "./4/ProcTHOR-Train-2264.scene_instance.json", + "./4/ProcTHOR-Train-2531.scene_instance.json", + "./4/ProcTHOR-Train-2776.scene_instance.json", + "./4/ProcTHOR-Train-2676.scene_instance.json", + "./4/ProcTHOR-Train-2136.scene_instance.json", + "./4/ProcTHOR-Train-2406.scene_instance.json", + "./4/ProcTHOR-Train-2784.scene_instance.json", + "./4/ProcTHOR-Train-2034.scene_instance.json", + "./4/ProcTHOR-Train-2861.scene_instance.json", + "./4/ProcTHOR-Train-2119.scene_instance.json", + "./4/ProcTHOR-Train-2625.scene_instance.json", + "./4/ProcTHOR-Train-2220.scene_instance.json", + "./4/ProcTHOR-Train-2822.scene_instance.json", + "./4/ProcTHOR-Train-2122.scene_instance.json", + "./4/ProcTHOR-Train-2161.scene_instance.json", + "./4/ProcTHOR-Train-2276.scene_instance.json", + "./4/ProcTHOR-Train-2469.scene_instance.json", + "./4/ProcTHOR-Train-2081.scene_instance.json", + "./4/ProcTHOR-Train-2292.scene_instance.json", + "./4/ProcTHOR-Train-2947.scene_instance.json", + "./4/ProcTHOR-Train-2962.scene_instance.json", + "./4/ProcTHOR-Train-2278.scene_instance.json", + "./4/ProcTHOR-Train-2674.scene_instance.json", + "./4/ProcTHOR-Train-2731.scene_instance.json", + "./4/ProcTHOR-Train-2338.scene_instance.json", + "./4/ProcTHOR-Train-2239.scene_instance.json", + "./4/ProcTHOR-Train-2480.scene_instance.json", + "./4/ProcTHOR-Train-2398.scene_instance.json", + "./4/ProcTHOR-Train-2455.scene_instance.json", + "./4/ProcTHOR-Train-2973.scene_instance.json", + "./4/ProcTHOR-Train-2562.scene_instance.json", + "./4/ProcTHOR-Train-2509.scene_instance.json", + "./4/ProcTHOR-Train-2886.scene_instance.json", + "./4/ProcTHOR-Train-2419.scene_instance.json", + "./4/ProcTHOR-Train-2516.scene_instance.json", + "./4/ProcTHOR-Train-2860.scene_instance.json", + "./4/ProcTHOR-Train-2375.scene_instance.json", + "./4/ProcTHOR-Train-2381.scene_instance.json", + "./4/ProcTHOR-Train-2727.scene_instance.json", + "./4/ProcTHOR-Train-2024.scene_instance.json", + "./4/ProcTHOR-Train-2114.scene_instance.json", + "./4/ProcTHOR-Train-2187.scene_instance.json", + "./4/ProcTHOR-Train-2713.scene_instance.json", + "./4/ProcTHOR-Train-2628.scene_instance.json", + "./4/ProcTHOR-Train-2547.scene_instance.json", + "./4/ProcTHOR-Train-2181.scene_instance.json", + "./4/ProcTHOR-Train-2792.scene_instance.json", + "./4/ProcTHOR-Train-2835.scene_instance.json", + "./4/ProcTHOR-Train-2098.scene_instance.json", + "./4/ProcTHOR-Train-2640.scene_instance.json", + "./4/ProcTHOR-Train-2591.scene_instance.json", + "./4/ProcTHOR-Train-2935.scene_instance.json", + "./4/ProcTHOR-Train-2843.scene_instance.json", + "./4/ProcTHOR-Train-2500.scene_instance.json", + "./4/ProcTHOR-Train-2386.scene_instance.json", + "./4/ProcTHOR-Train-2430.scene_instance.json", + "./4/ProcTHOR-Train-2144.scene_instance.json", + "./4/ProcTHOR-Train-2744.scene_instance.json", + "./4/ProcTHOR-Train-2535.scene_instance.json", + "./4/ProcTHOR-Train-2166.scene_instance.json", + "./4/ProcTHOR-Train-2551.scene_instance.json", + "./4/ProcTHOR-Train-2655.scene_instance.json", + "./4/ProcTHOR-Train-2925.scene_instance.json", + "./4/ProcTHOR-Train-2435.scene_instance.json", + "./4/ProcTHOR-Train-2038.scene_instance.json", + "./4/ProcTHOR-Train-2156.scene_instance.json", + "./4/ProcTHOR-Train-2583.scene_instance.json", + "./4/ProcTHOR-Train-2536.scene_instance.json", + "./4/ProcTHOR-Train-2630.scene_instance.json", + "./4/ProcTHOR-Train-2127.scene_instance.json", + "./4/ProcTHOR-Train-2987.scene_instance.json", + "./4/ProcTHOR-Train-2464.scene_instance.json", + "./4/ProcTHOR-Train-2226.scene_instance.json", + "./4/ProcTHOR-Train-2222.scene_instance.json", + "./4/ProcTHOR-Train-2061.scene_instance.json", + "./4/ProcTHOR-Train-2768.scene_instance.json", + "./4/ProcTHOR-Train-2959.scene_instance.json", + "./4/ProcTHOR-Train-2661.scene_instance.json", + "./4/ProcTHOR-Train-2902.scene_instance.json", + "./4/ProcTHOR-Train-2100.scene_instance.json", + "./4/ProcTHOR-Train-2794.scene_instance.json", + "./4/ProcTHOR-Train-2767.scene_instance.json", + "./4/ProcTHOR-Train-2668.scene_instance.json", + "./4/ProcTHOR-Train-2475.scene_instance.json", + "./4/ProcTHOR-Train-2099.scene_instance.json", + "./4/ProcTHOR-Train-2553.scene_instance.json", + "./4/ProcTHOR-Train-2407.scene_instance.json", + "./4/ProcTHOR-Train-2443.scene_instance.json", + "./4/ProcTHOR-Train-2564.scene_instance.json", + "./4/ProcTHOR-Train-2699.scene_instance.json", + "./4/ProcTHOR-Train-2331.scene_instance.json", + "./4/ProcTHOR-Train-2020.scene_instance.json", + "./4/ProcTHOR-Train-2662.scene_instance.json", + "./4/ProcTHOR-Train-2542.scene_instance.json", + "./4/ProcTHOR-Train-2317.scene_instance.json", + "./4/ProcTHOR-Train-2201.scene_instance.json", + "./4/ProcTHOR-Train-2005.scene_instance.json", + "./4/ProcTHOR-Train-2179.scene_instance.json", + "./4/ProcTHOR-Train-2637.scene_instance.json", + "./4/ProcTHOR-Train-2109.scene_instance.json", + "./4/ProcTHOR-Train-2762.scene_instance.json", + "./4/ProcTHOR-Train-2240.scene_instance.json", + "./4/ProcTHOR-Train-2287.scene_instance.json", + "./4/ProcTHOR-Train-2943.scene_instance.json", + "./4/ProcTHOR-Train-2000.scene_instance.json", + "./4/ProcTHOR-Train-2517.scene_instance.json", + "./4/ProcTHOR-Train-2529.scene_instance.json", + "./4/ProcTHOR-Train-2140.scene_instance.json", + "./4/ProcTHOR-Train-2428.scene_instance.json", + "./4/ProcTHOR-Train-2751.scene_instance.json", + "./4/ProcTHOR-Train-2548.scene_instance.json", + "./4/ProcTHOR-Train-2921.scene_instance.json", + "./4/ProcTHOR-Train-2867.scene_instance.json", + "./4/ProcTHOR-Train-2836.scene_instance.json", + "./4/ProcTHOR-Train-2312.scene_instance.json", + "./4/ProcTHOR-Train-2471.scene_instance.json", + "./4/ProcTHOR-Train-2627.scene_instance.json", + "./4/ProcTHOR-Train-2599.scene_instance.json", + "./4/ProcTHOR-Train-2919.scene_instance.json", + "./4/ProcTHOR-Train-2604.scene_instance.json", + "./4/ProcTHOR-Train-2023.scene_instance.json", + "./4/ProcTHOR-Train-2745.scene_instance.json", + "./4/ProcTHOR-Train-2809.scene_instance.json", + "./4/ProcTHOR-Train-2879.scene_instance.json", + "./4/ProcTHOR-Train-2064.scene_instance.json", + "./4/ProcTHOR-Train-2453.scene_instance.json", + "./4/ProcTHOR-Train-2490.scene_instance.json", + "./4/ProcTHOR-Train-2275.scene_instance.json", + "./4/ProcTHOR-Train-2853.scene_instance.json", + "./4/ProcTHOR-Train-2696.scene_instance.json", + "./4/ProcTHOR-Train-2224.scene_instance.json", + "./4/ProcTHOR-Train-2817.scene_instance.json", + "./4/ProcTHOR-Train-2367.scene_instance.json", + "./4/ProcTHOR-Train-2164.scene_instance.json", + "./4/ProcTHOR-Train-2904.scene_instance.json", + "./4/ProcTHOR-Train-2197.scene_instance.json", + "./4/ProcTHOR-Train-2994.scene_instance.json", + "./4/ProcTHOR-Train-2602.scene_instance.json", + "./4/ProcTHOR-Train-2942.scene_instance.json", + "./4/ProcTHOR-Train-2964.scene_instance.json", + "./4/ProcTHOR-Train-2035.scene_instance.json", + "./4/ProcTHOR-Train-2128.scene_instance.json", + "./4/ProcTHOR-Train-2720.scene_instance.json", + "./4/ProcTHOR-Train-2606.scene_instance.json", + "./4/ProcTHOR-Train-2667.scene_instance.json", + "./4/ProcTHOR-Train-2009.scene_instance.json", + "./4/ProcTHOR-Train-2336.scene_instance.json", + "./4/ProcTHOR-Train-2895.scene_instance.json", + "./4/ProcTHOR-Train-2189.scene_instance.json", + "./4/ProcTHOR-Train-2495.scene_instance.json", + "./4/ProcTHOR-Train-2063.scene_instance.json", + "./4/ProcTHOR-Train-2643.scene_instance.json", + "./4/ProcTHOR-Train-2046.scene_instance.json", + "./4/ProcTHOR-Train-2204.scene_instance.json", + "./4/ProcTHOR-Train-2356.scene_instance.json", + "./4/ProcTHOR-Train-2558.scene_instance.json", + "./4/ProcTHOR-Train-2232.scene_instance.json", + "./4/ProcTHOR-Train-2582.scene_instance.json", + "./4/ProcTHOR-Train-2053.scene_instance.json", + "./4/ProcTHOR-Train-2778.scene_instance.json", + "./4/ProcTHOR-Train-2850.scene_instance.json", + "./4/ProcTHOR-Train-2722.scene_instance.json", + "./4/ProcTHOR-Train-2074.scene_instance.json", + "./4/ProcTHOR-Train-2346.scene_instance.json", + "./4/ProcTHOR-Train-2829.scene_instance.json", + "./4/ProcTHOR-Train-2688.scene_instance.json", + "./4/ProcTHOR-Train-2372.scene_instance.json", + "./4/ProcTHOR-Train-2820.scene_instance.json", + "./4/ProcTHOR-Train-2856.scene_instance.json", + "./4/ProcTHOR-Train-2377.scene_instance.json", + "./4/ProcTHOR-Train-2759.scene_instance.json", + "./4/ProcTHOR-Train-2819.scene_instance.json", + "./4/ProcTHOR-Train-2466.scene_instance.json", + "./4/ProcTHOR-Train-2094.scene_instance.json", + "./4/ProcTHOR-Train-2171.scene_instance.json", + "./4/ProcTHOR-Train-2834.scene_instance.json", + "./4/ProcTHOR-Train-2483.scene_instance.json", + "./4/ProcTHOR-Train-2570.scene_instance.json", + "./4/ProcTHOR-Train-2593.scene_instance.json", + "./4/ProcTHOR-Train-2135.scene_instance.json", + "./4/ProcTHOR-Train-2545.scene_instance.json", + "./4/ProcTHOR-Train-2273.scene_instance.json", + "./4/ProcTHOR-Train-2092.scene_instance.json", + "./4/ProcTHOR-Train-2631.scene_instance.json", + "./4/ProcTHOR-Train-2815.scene_instance.json", + "./4/ProcTHOR-Train-2849.scene_instance.json", + "./4/ProcTHOR-Train-2082.scene_instance.json", + "./4/ProcTHOR-Train-2339.scene_instance.json", + "./4/ProcTHOR-Train-2613.scene_instance.json", + "./4/ProcTHOR-Train-2568.scene_instance.json", + "./4/ProcTHOR-Train-2672.scene_instance.json", + "./4/ProcTHOR-Train-2983.scene_instance.json", + "./4/ProcTHOR-Train-2290.scene_instance.json", + "./4/ProcTHOR-Train-2960.scene_instance.json", + "./4/ProcTHOR-Train-2840.scene_instance.json", + "./4/ProcTHOR-Train-2683.scene_instance.json", + "./8/ProcTHOR-Train-6563.scene_instance.json", + "./8/ProcTHOR-Train-6871.scene_instance.json", + "./8/ProcTHOR-Train-6559.scene_instance.json", + "./8/ProcTHOR-Train-6241.scene_instance.json", + "./8/ProcTHOR-Train-6198.scene_instance.json", + "./8/ProcTHOR-Train-6928.scene_instance.json", + "./8/ProcTHOR-Train-6898.scene_instance.json", + "./8/ProcTHOR-Train-6759.scene_instance.json", + "./8/ProcTHOR-Train-6843.scene_instance.json", + "./8/ProcTHOR-Train-6942.scene_instance.json", + "./8/ProcTHOR-Train-6880.scene_instance.json", + "./8/ProcTHOR-Train-6298.scene_instance.json", + "./8/ProcTHOR-Train-6766.scene_instance.json", + "./8/ProcTHOR-Train-6044.scene_instance.json", + "./8/ProcTHOR-Train-6518.scene_instance.json", + "./8/ProcTHOR-Train-6119.scene_instance.json", + "./8/ProcTHOR-Train-6628.scene_instance.json", + "./8/ProcTHOR-Train-6691.scene_instance.json", + "./8/ProcTHOR-Train-6605.scene_instance.json", + "./8/ProcTHOR-Train-6161.scene_instance.json", + "./8/ProcTHOR-Train-6314.scene_instance.json", + "./8/ProcTHOR-Train-6899.scene_instance.json", + "./8/ProcTHOR-Train-6372.scene_instance.json", + "./8/ProcTHOR-Train-6208.scene_instance.json", + "./8/ProcTHOR-Train-6840.scene_instance.json", + "./8/ProcTHOR-Train-6606.scene_instance.json", + "./8/ProcTHOR-Train-6274.scene_instance.json", + "./8/ProcTHOR-Train-6979.scene_instance.json", + "./8/ProcTHOR-Train-6656.scene_instance.json", + "./8/ProcTHOR-Train-6578.scene_instance.json", + "./8/ProcTHOR-Train-6727.scene_instance.json", + "./8/ProcTHOR-Train-6674.scene_instance.json", + "./8/ProcTHOR-Train-6111.scene_instance.json", + "./8/ProcTHOR-Train-6005.scene_instance.json", + "./8/ProcTHOR-Train-6412.scene_instance.json", + "./8/ProcTHOR-Train-6346.scene_instance.json", + "./8/ProcTHOR-Train-6019.scene_instance.json", + "./8/ProcTHOR-Train-6530.scene_instance.json", + "./8/ProcTHOR-Train-6095.scene_instance.json", + "./8/ProcTHOR-Train-6268.scene_instance.json", + "./8/ProcTHOR-Train-6615.scene_instance.json", + "./8/ProcTHOR-Train-6040.scene_instance.json", + "./8/ProcTHOR-Train-6144.scene_instance.json", + "./8/ProcTHOR-Train-6841.scene_instance.json", + "./8/ProcTHOR-Train-6894.scene_instance.json", + "./8/ProcTHOR-Train-6920.scene_instance.json", + "./8/ProcTHOR-Train-6376.scene_instance.json", + "./8/ProcTHOR-Train-6670.scene_instance.json", + "./8/ProcTHOR-Train-6092.scene_instance.json", + "./8/ProcTHOR-Train-6201.scene_instance.json", + "./8/ProcTHOR-Train-6199.scene_instance.json", + "./8/ProcTHOR-Train-6694.scene_instance.json", + "./8/ProcTHOR-Train-6410.scene_instance.json", + "./8/ProcTHOR-Train-6702.scene_instance.json", + "./8/ProcTHOR-Train-6012.scene_instance.json", + "./8/ProcTHOR-Train-6164.scene_instance.json", + "./8/ProcTHOR-Train-6173.scene_instance.json", + "./8/ProcTHOR-Train-6875.scene_instance.json", + "./8/ProcTHOR-Train-6834.scene_instance.json", + "./8/ProcTHOR-Train-6756.scene_instance.json", + "./8/ProcTHOR-Train-6649.scene_instance.json", + "./8/ProcTHOR-Train-6782.scene_instance.json", + "./8/ProcTHOR-Train-6456.scene_instance.json", + "./8/ProcTHOR-Train-6519.scene_instance.json", + "./8/ProcTHOR-Train-6761.scene_instance.json", + "./8/ProcTHOR-Train-6897.scene_instance.json", + "./8/ProcTHOR-Train-6055.scene_instance.json", + "./8/ProcTHOR-Train-6984.scene_instance.json", + "./8/ProcTHOR-Train-6579.scene_instance.json", + "./8/ProcTHOR-Train-6784.scene_instance.json", + "./8/ProcTHOR-Train-6477.scene_instance.json", + "./8/ProcTHOR-Train-6774.scene_instance.json", + "./8/ProcTHOR-Train-6413.scene_instance.json", + "./8/ProcTHOR-Train-6253.scene_instance.json", + "./8/ProcTHOR-Train-6496.scene_instance.json", + "./8/ProcTHOR-Train-6625.scene_instance.json", + "./8/ProcTHOR-Train-6154.scene_instance.json", + "./8/ProcTHOR-Train-6502.scene_instance.json", + "./8/ProcTHOR-Train-6654.scene_instance.json", + "./8/ProcTHOR-Train-6990.scene_instance.json", + "./8/ProcTHOR-Train-6735.scene_instance.json", + "./8/ProcTHOR-Train-6767.scene_instance.json", + "./8/ProcTHOR-Train-6010.scene_instance.json", + "./8/ProcTHOR-Train-6783.scene_instance.json", + "./8/ProcTHOR-Train-6575.scene_instance.json", + "./8/ProcTHOR-Train-6550.scene_instance.json", + "./8/ProcTHOR-Train-6520.scene_instance.json", + "./8/ProcTHOR-Train-6438.scene_instance.json", + "./8/ProcTHOR-Train-6685.scene_instance.json", + "./8/ProcTHOR-Train-6827.scene_instance.json", + "./8/ProcTHOR-Train-6390.scene_instance.json", + "./8/ProcTHOR-Train-6485.scene_instance.json", + "./8/ProcTHOR-Train-6583.scene_instance.json", + "./8/ProcTHOR-Train-6382.scene_instance.json", + "./8/ProcTHOR-Train-6796.scene_instance.json", + "./8/ProcTHOR-Train-6823.scene_instance.json", + "./8/ProcTHOR-Train-6752.scene_instance.json", + "./8/ProcTHOR-Train-6657.scene_instance.json", + "./8/ProcTHOR-Train-6104.scene_instance.json", + "./8/ProcTHOR-Train-6510.scene_instance.json", + "./8/ProcTHOR-Train-6636.scene_instance.json", + "./8/ProcTHOR-Train-6721.scene_instance.json", + "./8/ProcTHOR-Train-6741.scene_instance.json", + "./8/ProcTHOR-Train-6788.scene_instance.json", + "./8/ProcTHOR-Train-6861.scene_instance.json", + "./8/ProcTHOR-Train-6812.scene_instance.json", + "./8/ProcTHOR-Train-6102.scene_instance.json", + "./8/ProcTHOR-Train-6972.scene_instance.json", + "./8/ProcTHOR-Train-6478.scene_instance.json", + "./8/ProcTHOR-Train-6467.scene_instance.json", + "./8/ProcTHOR-Train-6000.scene_instance.json", + "./8/ProcTHOR-Train-6803.scene_instance.json", + "./8/ProcTHOR-Train-6754.scene_instance.json", + "./8/ProcTHOR-Train-6931.scene_instance.json", + "./8/ProcTHOR-Train-6214.scene_instance.json", + "./8/ProcTHOR-Train-6751.scene_instance.json", + "./8/ProcTHOR-Train-6637.scene_instance.json", + "./8/ProcTHOR-Train-6703.scene_instance.json", + "./8/ProcTHOR-Train-6876.scene_instance.json", + "./8/ProcTHOR-Train-6115.scene_instance.json", + "./8/ProcTHOR-Train-6584.scene_instance.json", + "./8/ProcTHOR-Train-6919.scene_instance.json", + "./8/ProcTHOR-Train-6912.scene_instance.json", + "./8/ProcTHOR-Train-6490.scene_instance.json", + "./8/ProcTHOR-Train-6739.scene_instance.json", + "./8/ProcTHOR-Train-6472.scene_instance.json", + "./8/ProcTHOR-Train-6557.scene_instance.json", + "./8/ProcTHOR-Train-6836.scene_instance.json", + "./8/ProcTHOR-Train-6862.scene_instance.json", + "./8/ProcTHOR-Train-6817.scene_instance.json", + "./8/ProcTHOR-Train-6455.scene_instance.json", + "./8/ProcTHOR-Train-6917.scene_instance.json", + "./8/ProcTHOR-Train-6958.scene_instance.json", + "./8/ProcTHOR-Train-6209.scene_instance.json", + "./8/ProcTHOR-Train-6064.scene_instance.json", + "./8/ProcTHOR-Train-6306.scene_instance.json", + "./8/ProcTHOR-Train-6313.scene_instance.json", + "./8/ProcTHOR-Train-6165.scene_instance.json", + "./8/ProcTHOR-Train-6659.scene_instance.json", + "./8/ProcTHOR-Train-6048.scene_instance.json", + "./8/ProcTHOR-Train-6800.scene_instance.json", + "./8/ProcTHOR-Train-6367.scene_instance.json", + "./8/ProcTHOR-Train-6062.scene_instance.json", + "./8/ProcTHOR-Train-6757.scene_instance.json", + "./8/ProcTHOR-Train-6881.scene_instance.json", + "./8/ProcTHOR-Train-6460.scene_instance.json", + "./8/ProcTHOR-Train-6028.scene_instance.json", + "./8/ProcTHOR-Train-6088.scene_instance.json", + "./8/ProcTHOR-Train-6976.scene_instance.json", + "./8/ProcTHOR-Train-6921.scene_instance.json", + "./8/ProcTHOR-Train-6811.scene_instance.json", + "./8/ProcTHOR-Train-6326.scene_instance.json", + "./8/ProcTHOR-Train-6551.scene_instance.json", + "./8/ProcTHOR-Train-6607.scene_instance.json", + "./8/ProcTHOR-Train-6989.scene_instance.json", + "./8/ProcTHOR-Train-6083.scene_instance.json", + "./8/ProcTHOR-Train-6450.scene_instance.json", + "./8/ProcTHOR-Train-6203.scene_instance.json", + "./8/ProcTHOR-Train-6193.scene_instance.json", + "./8/ProcTHOR-Train-6779.scene_instance.json", + "./8/ProcTHOR-Train-6492.scene_instance.json", + "./8/ProcTHOR-Train-6077.scene_instance.json", + "./8/ProcTHOR-Train-6639.scene_instance.json", + "./8/ProcTHOR-Train-6337.scene_instance.json", + "./8/ProcTHOR-Train-6265.scene_instance.json", + "./8/ProcTHOR-Train-6994.scene_instance.json", + "./8/ProcTHOR-Train-6212.scene_instance.json", + "./8/ProcTHOR-Train-6819.scene_instance.json", + "./8/ProcTHOR-Train-6213.scene_instance.json", + "./8/ProcTHOR-Train-6679.scene_instance.json", + "./8/ProcTHOR-Train-6907.scene_instance.json", + "./8/ProcTHOR-Train-6913.scene_instance.json", + "./8/ProcTHOR-Train-6231.scene_instance.json", + "./8/ProcTHOR-Train-6142.scene_instance.json", + "./8/ProcTHOR-Train-6421.scene_instance.json", + "./8/ProcTHOR-Train-6744.scene_instance.json", + "./8/ProcTHOR-Train-6786.scene_instance.json", + "./8/ProcTHOR-Train-6609.scene_instance.json", + "./8/ProcTHOR-Train-6127.scene_instance.json", + "./8/ProcTHOR-Train-6386.scene_instance.json", + "./8/ProcTHOR-Train-6802.scene_instance.json", + "./8/ProcTHOR-Train-6162.scene_instance.json", + "./8/ProcTHOR-Train-6542.scene_instance.json", + "./8/ProcTHOR-Train-6889.scene_instance.json", + "./8/ProcTHOR-Train-6085.scene_instance.json", + "./8/ProcTHOR-Train-6041.scene_instance.json", + "./8/ProcTHOR-Train-6663.scene_instance.json", + "./8/ProcTHOR-Train-6857.scene_instance.json", + "./8/ProcTHOR-Train-6521.scene_instance.json", + "./8/ProcTHOR-Train-6874.scene_instance.json", + "./8/ProcTHOR-Train-6500.scene_instance.json", + "./8/ProcTHOR-Train-6328.scene_instance.json", + "./8/ProcTHOR-Train-6234.scene_instance.json", + "./8/ProcTHOR-Train-6962.scene_instance.json", + "./8/ProcTHOR-Train-6617.scene_instance.json", + "./8/ProcTHOR-Train-6242.scene_instance.json", + "./8/ProcTHOR-Train-6833.scene_instance.json", + "./8/ProcTHOR-Train-6200.scene_instance.json", + "./8/ProcTHOR-Train-6776.scene_instance.json", + "./8/ProcTHOR-Train-6664.scene_instance.json", + "./8/ProcTHOR-Train-6333.scene_instance.json", + "./8/ProcTHOR-Train-6264.scene_instance.json", + "./8/ProcTHOR-Train-6797.scene_instance.json", + "./8/ProcTHOR-Train-6687.scene_instance.json", + "./8/ProcTHOR-Train-6190.scene_instance.json", + "./8/ProcTHOR-Train-6793.scene_instance.json", + "./8/ProcTHOR-Train-6006.scene_instance.json", + "./8/ProcTHOR-Train-6592.scene_instance.json", + "./8/ProcTHOR-Train-6590.scene_instance.json", + "./8/ProcTHOR-Train-6804.scene_instance.json", + "./8/ProcTHOR-Train-6589.scene_instance.json", + "./8/ProcTHOR-Train-6180.scene_instance.json", + "./8/ProcTHOR-Train-6864.scene_instance.json", + "./8/ProcTHOR-Train-6309.scene_instance.json", + "./8/ProcTHOR-Train-6938.scene_instance.json", + "./8/ProcTHOR-Train-6420.scene_instance.json", + "./8/ProcTHOR-Train-6432.scene_instance.json", + "./8/ProcTHOR-Train-6746.scene_instance.json", + "./8/ProcTHOR-Train-6120.scene_instance.json", + "./8/ProcTHOR-Train-6440.scene_instance.json", + "./8/ProcTHOR-Train-6266.scene_instance.json", + "./8/ProcTHOR-Train-6580.scene_instance.json", + "./8/ProcTHOR-Train-6352.scene_instance.json", + "./8/ProcTHOR-Train-6089.scene_instance.json", + "./8/ProcTHOR-Train-6187.scene_instance.json", + "./8/ProcTHOR-Train-6582.scene_instance.json", + "./8/ProcTHOR-Train-6896.scene_instance.json", + "./8/ProcTHOR-Train-6099.scene_instance.json", + "./8/ProcTHOR-Train-6622.scene_instance.json", + "./8/ProcTHOR-Train-6391.scene_instance.json", + "./8/ProcTHOR-Train-6821.scene_instance.json", + "./8/ProcTHOR-Train-6888.scene_instance.json", + "./8/ProcTHOR-Train-6933.scene_instance.json", + "./8/ProcTHOR-Train-6830.scene_instance.json", + "./8/ProcTHOR-Train-6428.scene_instance.json", + "./8/ProcTHOR-Train-6357.scene_instance.json", + "./8/ProcTHOR-Train-6169.scene_instance.json", + "./8/ProcTHOR-Train-6058.scene_instance.json", + "./8/ProcTHOR-Train-6039.scene_instance.json", + "./8/ProcTHOR-Train-6018.scene_instance.json", + "./8/ProcTHOR-Train-6461.scene_instance.json", + "./8/ProcTHOR-Train-6982.scene_instance.json", + "./8/ProcTHOR-Train-6627.scene_instance.json", + "./8/ProcTHOR-Train-6015.scene_instance.json", + "./8/ProcTHOR-Train-6937.scene_instance.json", + "./8/ProcTHOR-Train-6879.scene_instance.json", + "./8/ProcTHOR-Train-6168.scene_instance.json", + "./8/ProcTHOR-Train-6983.scene_instance.json", + "./8/ProcTHOR-Train-6424.scene_instance.json", + "./8/ProcTHOR-Train-6374.scene_instance.json", + "./8/ProcTHOR-Train-6953.scene_instance.json", + "./8/ProcTHOR-Train-6736.scene_instance.json", + "./8/ProcTHOR-Train-6806.scene_instance.json", + "./8/ProcTHOR-Train-6277.scene_instance.json", + "./8/ProcTHOR-Train-6986.scene_instance.json", + "./8/ProcTHOR-Train-6118.scene_instance.json", + "./8/ProcTHOR-Train-6825.scene_instance.json", + "./8/ProcTHOR-Train-6343.scene_instance.json", + "./8/ProcTHOR-Train-6598.scene_instance.json", + "./8/ProcTHOR-Train-6027.scene_instance.json", + "./8/ProcTHOR-Train-6529.scene_instance.json", + "./8/ProcTHOR-Train-6726.scene_instance.json", + "./8/ProcTHOR-Train-6447.scene_instance.json", + "./8/ProcTHOR-Train-6866.scene_instance.json", + "./8/ProcTHOR-Train-6695.scene_instance.json", + "./8/ProcTHOR-Train-6973.scene_instance.json", + "./8/ProcTHOR-Train-6052.scene_instance.json", + "./8/ProcTHOR-Train-6228.scene_instance.json", + "./8/ProcTHOR-Train-6185.scene_instance.json", + "./8/ProcTHOR-Train-6728.scene_instance.json", + "./8/ProcTHOR-Train-6427.scene_instance.json", + "./8/ProcTHOR-Train-6284.scene_instance.json", + "./8/ProcTHOR-Train-6322.scene_instance.json", + "./8/ProcTHOR-Train-6071.scene_instance.json", + "./8/ProcTHOR-Train-6360.scene_instance.json", + "./8/ProcTHOR-Train-6855.scene_instance.json", + "./8/ProcTHOR-Train-6604.scene_instance.json", + "./8/ProcTHOR-Train-6411.scene_instance.json", + "./8/ProcTHOR-Train-6024.scene_instance.json", + "./8/ProcTHOR-Train-6423.scene_instance.json", + "./8/ProcTHOR-Train-6711.scene_instance.json", + "./8/ProcTHOR-Train-6397.scene_instance.json", + "./8/ProcTHOR-Train-6870.scene_instance.json", + "./8/ProcTHOR-Train-6612.scene_instance.json", + "./8/ProcTHOR-Train-6093.scene_instance.json", + "./8/ProcTHOR-Train-6323.scene_instance.json", + "./8/ProcTHOR-Train-6660.scene_instance.json", + "./8/ProcTHOR-Train-6196.scene_instance.json", + "./8/ProcTHOR-Train-6683.scene_instance.json", + "./8/ProcTHOR-Train-6873.scene_instance.json", + "./8/ProcTHOR-Train-6471.scene_instance.json", + "./8/ProcTHOR-Train-6398.scene_instance.json", + "./8/ProcTHOR-Train-6449.scene_instance.json", + "./8/ProcTHOR-Train-6775.scene_instance.json", + "./8/ProcTHOR-Train-6226.scene_instance.json", + "./8/ProcTHOR-Train-6916.scene_instance.json", + "./8/ProcTHOR-Train-6336.scene_instance.json", + "./8/ProcTHOR-Train-6668.scene_instance.json", + "./8/ProcTHOR-Train-6338.scene_instance.json", + "./8/ProcTHOR-Train-6718.scene_instance.json", + "./8/ProcTHOR-Train-6672.scene_instance.json", + "./8/ProcTHOR-Train-6170.scene_instance.json", + "./8/ProcTHOR-Train-6616.scene_instance.json", + "./8/ProcTHOR-Train-6495.scene_instance.json", + "./8/ProcTHOR-Train-6522.scene_instance.json", + "./8/ProcTHOR-Train-6572.scene_instance.json", + "./8/ProcTHOR-Train-6509.scene_instance.json", + "./8/ProcTHOR-Train-6961.scene_instance.json", + "./8/ProcTHOR-Train-6004.scene_instance.json", + "./8/ProcTHOR-Train-6747.scene_instance.json", + "./8/ProcTHOR-Train-6713.scene_instance.json", + "./8/ProcTHOR-Train-6247.scene_instance.json", + "./8/ProcTHOR-Train-6081.scene_instance.json", + "./8/ProcTHOR-Train-6561.scene_instance.json", + "./8/ProcTHOR-Train-6516.scene_instance.json", + "./8/ProcTHOR-Train-6731.scene_instance.json", + "./8/ProcTHOR-Train-6558.scene_instance.json", + "./8/ProcTHOR-Train-6941.scene_instance.json", + "./8/ProcTHOR-Train-6361.scene_instance.json", + "./8/ProcTHOR-Train-6462.scene_instance.json", + "./8/ProcTHOR-Train-6020.scene_instance.json", + "./8/ProcTHOR-Train-6764.scene_instance.json", + "./8/ProcTHOR-Train-6709.scene_instance.json", + "./8/ProcTHOR-Train-6945.scene_instance.json", + "./8/ProcTHOR-Train-6614.scene_instance.json", + "./8/ProcTHOR-Train-6112.scene_instance.json", + "./8/ProcTHOR-Train-6923.scene_instance.json", + "./8/ProcTHOR-Train-6524.scene_instance.json", + "./8/ProcTHOR-Train-6255.scene_instance.json", + "./8/ProcTHOR-Train-6418.scene_instance.json", + "./8/ProcTHOR-Train-6329.scene_instance.json", + "./8/ProcTHOR-Train-6901.scene_instance.json", + "./8/ProcTHOR-Train-6128.scene_instance.json", + "./8/ProcTHOR-Train-6206.scene_instance.json", + "./8/ProcTHOR-Train-6904.scene_instance.json", + "./8/ProcTHOR-Train-6354.scene_instance.json", + "./8/ProcTHOR-Train-6435.scene_instance.json", + "./8/ProcTHOR-Train-6750.scene_instance.json", + "./8/ProcTHOR-Train-6715.scene_instance.json", + "./8/ProcTHOR-Train-6552.scene_instance.json", + "./8/ProcTHOR-Train-6194.scene_instance.json", + "./8/ProcTHOR-Train-6330.scene_instance.json", + "./8/ProcTHOR-Train-6385.scene_instance.json", + "./8/ProcTHOR-Train-6070.scene_instance.json", + "./8/ProcTHOR-Train-6315.scene_instance.json", + "./8/ProcTHOR-Train-6554.scene_instance.json", + "./8/ProcTHOR-Train-6191.scene_instance.json", + "./8/ProcTHOR-Train-6302.scene_instance.json", + "./8/ProcTHOR-Train-6008.scene_instance.json", + "./8/ProcTHOR-Train-6281.scene_instance.json", + "./8/ProcTHOR-Train-6676.scene_instance.json", + "./8/ProcTHOR-Train-6216.scene_instance.json", + "./8/ProcTHOR-Train-6902.scene_instance.json", + "./8/ProcTHOR-Train-6466.scene_instance.json", + "./8/ProcTHOR-Train-6163.scene_instance.json", + "./8/ProcTHOR-Train-6221.scene_instance.json", + "./8/ProcTHOR-Train-6387.scene_instance.json", + "./8/ProcTHOR-Train-6183.scene_instance.json", + "./8/ProcTHOR-Train-6293.scene_instance.json", + "./8/ProcTHOR-Train-6555.scene_instance.json", + "./8/ProcTHOR-Train-6446.scene_instance.json", + "./8/ProcTHOR-Train-6848.scene_instance.json", + "./8/ProcTHOR-Train-6459.scene_instance.json", + "./8/ProcTHOR-Train-6045.scene_instance.json", + "./8/ProcTHOR-Train-6034.scene_instance.json", + "./8/ProcTHOR-Train-6408.scene_instance.json", + "./8/ProcTHOR-Train-6065.scene_instance.json", + "./8/ProcTHOR-Train-6132.scene_instance.json", + "./8/ProcTHOR-Train-6696.scene_instance.json", + "./8/ProcTHOR-Train-6220.scene_instance.json", + "./8/ProcTHOR-Train-6192.scene_instance.json", + "./8/ProcTHOR-Train-6653.scene_instance.json", + "./8/ProcTHOR-Train-6121.scene_instance.json", + "./8/ProcTHOR-Train-6136.scene_instance.json", + "./8/ProcTHOR-Train-6470.scene_instance.json", + "./8/ProcTHOR-Train-6113.scene_instance.json", + "./8/ProcTHOR-Train-6526.scene_instance.json", + "./8/ProcTHOR-Train-6623.scene_instance.json", + "./8/ProcTHOR-Train-6968.scene_instance.json", + "./8/ProcTHOR-Train-6856.scene_instance.json", + "./8/ProcTHOR-Train-6877.scene_instance.json", + "./8/ProcTHOR-Train-6772.scene_instance.json", + "./8/ProcTHOR-Train-6743.scene_instance.json", + "./8/ProcTHOR-Train-6799.scene_instance.json", + "./8/ProcTHOR-Train-6515.scene_instance.json", + "./8/ProcTHOR-Train-6054.scene_instance.json", + "./8/ProcTHOR-Train-6611.scene_instance.json", + "./8/ProcTHOR-Train-6560.scene_instance.json", + "./8/ProcTHOR-Train-6157.scene_instance.json", + "./8/ProcTHOR-Train-6033.scene_instance.json", + "./8/ProcTHOR-Train-6393.scene_instance.json", + "./8/ProcTHOR-Train-6295.scene_instance.json", + "./8/ProcTHOR-Train-6319.scene_instance.json", + "./8/ProcTHOR-Train-6568.scene_instance.json", + "./8/ProcTHOR-Train-6032.scene_instance.json", + "./8/ProcTHOR-Train-6537.scene_instance.json", + "./8/ProcTHOR-Train-6725.scene_instance.json", + "./8/ProcTHOR-Train-6723.scene_instance.json", + "./8/ProcTHOR-Train-6565.scene_instance.json", + "./8/ProcTHOR-Train-6249.scene_instance.json", + "./8/ProcTHOR-Train-6716.scene_instance.json", + "./8/ProcTHOR-Train-6947.scene_instance.json", + "./8/ProcTHOR-Train-6753.scene_instance.json", + "./8/ProcTHOR-Train-6740.scene_instance.json", + "./8/ProcTHOR-Train-6908.scene_instance.json", + "./8/ProcTHOR-Train-6454.scene_instance.json", + "./8/ProcTHOR-Train-6595.scene_instance.json", + "./8/ProcTHOR-Train-6824.scene_instance.json", + "./8/ProcTHOR-Train-6729.scene_instance.json", + "./8/ProcTHOR-Train-6886.scene_instance.json", + "./8/ProcTHOR-Train-6810.scene_instance.json", + "./8/ProcTHOR-Train-6787.scene_instance.json", + "./8/ProcTHOR-Train-6405.scene_instance.json", + "./8/ProcTHOR-Train-6665.scene_instance.json", + "./8/ProcTHOR-Train-6178.scene_instance.json", + "./8/ProcTHOR-Train-6669.scene_instance.json", + "./8/ProcTHOR-Train-6341.scene_instance.json", + "./8/ProcTHOR-Train-6630.scene_instance.json", + "./8/ProcTHOR-Train-6072.scene_instance.json", + "./8/ProcTHOR-Train-6720.scene_instance.json", + "./8/ProcTHOR-Train-6635.scene_instance.json", + "./8/ProcTHOR-Train-6124.scene_instance.json", + "./8/ProcTHOR-Train-6987.scene_instance.json", + "./8/ProcTHOR-Train-6396.scene_instance.json", + "./8/ProcTHOR-Train-6219.scene_instance.json", + "./8/ProcTHOR-Train-6497.scene_instance.json", + "./8/ProcTHOR-Train-6347.scene_instance.json", + "./8/ProcTHOR-Train-6971.scene_instance.json", + "./8/ProcTHOR-Train-6705.scene_instance.json", + "./8/ProcTHOR-Train-6355.scene_instance.json", + "./8/ProcTHOR-Train-6002.scene_instance.json", + "./8/ProcTHOR-Train-6407.scene_instance.json", + "./8/ProcTHOR-Train-6248.scene_instance.json", + "./8/ProcTHOR-Train-6749.scene_instance.json", + "./8/ProcTHOR-Train-6693.scene_instance.json", + "./8/ProcTHOR-Train-6570.scene_instance.json", + "./8/ProcTHOR-Train-6860.scene_instance.json", + "./8/ProcTHOR-Train-6822.scene_instance.json", + "./8/ProcTHOR-Train-6808.scene_instance.json", + "./8/ProcTHOR-Train-6016.scene_instance.json", + "./8/ProcTHOR-Train-6240.scene_instance.json", + "./8/ProcTHOR-Train-6320.scene_instance.json", + "./8/ProcTHOR-Train-6025.scene_instance.json", + "./8/ProcTHOR-Train-6770.scene_instance.json", + "./8/ProcTHOR-Train-6493.scene_instance.json", + "./8/ProcTHOR-Train-6998.scene_instance.json", + "./8/ProcTHOR-Train-6981.scene_instance.json", + "./8/ProcTHOR-Train-6599.scene_instance.json", + "./8/ProcTHOR-Train-6682.scene_instance.json", + "./8/ProcTHOR-Train-6188.scene_instance.json", + "./8/ProcTHOR-Train-6227.scene_instance.json", + "./8/ProcTHOR-Train-6141.scene_instance.json", + "./8/ProcTHOR-Train-6527.scene_instance.json", + "./8/ProcTHOR-Train-6619.scene_instance.json", + "./8/ProcTHOR-Train-6126.scene_instance.json", + "./8/ProcTHOR-Train-6130.scene_instance.json", + "./8/ProcTHOR-Train-6134.scene_instance.json", + "./8/ProcTHOR-Train-6768.scene_instance.json", + "./8/ProcTHOR-Train-6780.scene_instance.json", + "./8/ProcTHOR-Train-6549.scene_instance.json", + "./8/ProcTHOR-Train-6069.scene_instance.json", + "./8/ProcTHOR-Train-6184.scene_instance.json", + "./8/ProcTHOR-Train-6851.scene_instance.json", + "./8/ProcTHOR-Train-6335.scene_instance.json", + "./8/ProcTHOR-Train-6975.scene_instance.json", + "./8/ProcTHOR-Train-6900.scene_instance.json", + "./8/ProcTHOR-Train-6262.scene_instance.json", + "./8/ProcTHOR-Train-6576.scene_instance.json", + "./8/ProcTHOR-Train-6566.scene_instance.json", + "./8/ProcTHOR-Train-6704.scene_instance.json", + "./8/ProcTHOR-Train-6437.scene_instance.json", + "./8/ProcTHOR-Train-6129.scene_instance.json", + "./8/ProcTHOR-Train-6895.scene_instance.json", + "./8/ProcTHOR-Train-6512.scene_instance.json", + "./8/ProcTHOR-Train-6771.scene_instance.json", + "./8/ProcTHOR-Train-6849.scene_instance.json", + "./8/ProcTHOR-Train-6207.scene_instance.json", + "./8/ProcTHOR-Train-6562.scene_instance.json", + "./8/ProcTHOR-Train-6400.scene_instance.json", + "./8/ProcTHOR-Train-6288.scene_instance.json", + "./8/ProcTHOR-Train-6905.scene_instance.json", + "./8/ProcTHOR-Train-6935.scene_instance.json", + "./8/ProcTHOR-Train-6312.scene_instance.json", + "./8/ProcTHOR-Train-6481.scene_instance.json", + "./8/ProcTHOR-Train-6416.scene_instance.json", + "./8/ProcTHOR-Train-6629.scene_instance.json", + "./8/ProcTHOR-Train-6090.scene_instance.json", + "./8/ProcTHOR-Train-6633.scene_instance.json", + "./8/ProcTHOR-Train-6536.scene_instance.json", + "./8/ProcTHOR-Train-6177.scene_instance.json", + "./8/ProcTHOR-Train-6722.scene_instance.json", + "./8/ProcTHOR-Train-6246.scene_instance.json", + "./8/ProcTHOR-Train-6545.scene_instance.json", + "./8/ProcTHOR-Train-6174.scene_instance.json", + "./8/ProcTHOR-Train-6151.scene_instance.json", + "./8/ProcTHOR-Train-6498.scene_instance.json", + "./8/ProcTHOR-Train-6331.scene_instance.json", + "./8/ProcTHOR-Train-6837.scene_instance.json", + "./8/ProcTHOR-Train-6237.scene_instance.json", + "./8/ProcTHOR-Train-6501.scene_instance.json", + "./8/ProcTHOR-Train-6513.scene_instance.json", + "./8/ProcTHOR-Train-6884.scene_instance.json", + "./8/ProcTHOR-Train-6909.scene_instance.json", + "./8/ProcTHOR-Train-6538.scene_instance.json", + "./8/ProcTHOR-Train-6815.scene_instance.json", + "./8/ProcTHOR-Train-6258.scene_instance.json", + "./8/ProcTHOR-Train-6991.scene_instance.json", + "./8/ProcTHOR-Train-6964.scene_instance.json", + "./8/ProcTHOR-Train-6351.scene_instance.json", + "./8/ProcTHOR-Train-6166.scene_instance.json", + "./8/ProcTHOR-Train-6285.scene_instance.json", + "./8/ProcTHOR-Train-6135.scene_instance.json", + "./8/ProcTHOR-Train-6114.scene_instance.json", + "./8/ProcTHOR-Train-6294.scene_instance.json", + "./8/ProcTHOR-Train-6745.scene_instance.json", + "./8/ProcTHOR-Train-6957.scene_instance.json", + "./8/ProcTHOR-Train-6535.scene_instance.json", + "./8/ProcTHOR-Train-6818.scene_instance.json", + "./8/ProcTHOR-Train-6404.scene_instance.json", + "./8/ProcTHOR-Train-6179.scene_instance.json", + "./8/ProcTHOR-Train-6893.scene_instance.json", + "./8/ProcTHOR-Train-6401.scene_instance.json", + "./8/ProcTHOR-Train-6859.scene_instance.json", + "./8/ProcTHOR-Train-6441.scene_instance.json", + "./8/ProcTHOR-Train-6890.scene_instance.json", + "./8/ProcTHOR-Train-6182.scene_instance.json", + "./8/ProcTHOR-Train-6773.scene_instance.json", + "./8/ProcTHOR-Train-6533.scene_instance.json", + "./8/ProcTHOR-Train-6358.scene_instance.json", + "./8/ProcTHOR-Train-6373.scene_instance.json", + "./8/ProcTHOR-Train-6539.scene_instance.json", + "./8/ProcTHOR-Train-6149.scene_instance.json", + "./8/ProcTHOR-Train-6078.scene_instance.json", + "./8/ProcTHOR-Train-6108.scene_instance.json", + "./8/ProcTHOR-Train-6236.scene_instance.json", + "./8/ProcTHOR-Train-6261.scene_instance.json", + "./8/ProcTHOR-Train-6666.scene_instance.json", + "./8/ProcTHOR-Train-6922.scene_instance.json", + "./8/ProcTHOR-Train-6813.scene_instance.json", + "./8/ProcTHOR-Train-6737.scene_instance.json", + "./8/ProcTHOR-Train-6205.scene_instance.json", + "./8/ProcTHOR-Train-6388.scene_instance.json", + "./8/ProcTHOR-Train-6359.scene_instance.json", + "./8/ProcTHOR-Train-6978.scene_instance.json", + "./8/ProcTHOR-Train-6632.scene_instance.json", + "./8/ProcTHOR-Train-6706.scene_instance.json", + "./8/ProcTHOR-Train-6712.scene_instance.json", + "./8/ProcTHOR-Train-6406.scene_instance.json", + "./8/ProcTHOR-Train-6468.scene_instance.json", + "./8/ProcTHOR-Train-6318.scene_instance.json", + "./8/ProcTHOR-Train-6967.scene_instance.json", + "./8/ProcTHOR-Train-6573.scene_instance.json", + "./8/ProcTHOR-Train-6924.scene_instance.json", + "./8/ProcTHOR-Train-6263.scene_instance.json", + "./8/ProcTHOR-Train-6152.scene_instance.json", + "./8/ProcTHOR-Train-6914.scene_instance.json", + "./8/ProcTHOR-Train-6176.scene_instance.json", + "./8/ProcTHOR-Train-6714.scene_instance.json", + "./8/ProcTHOR-Train-6887.scene_instance.json", + "./8/ProcTHOR-Train-6814.scene_instance.json", + "./8/ProcTHOR-Train-6297.scene_instance.json", + "./8/ProcTHOR-Train-6031.scene_instance.json", + "./8/ProcTHOR-Train-6433.scene_instance.json", + "./8/ProcTHOR-Train-6225.scene_instance.json", + "./8/ProcTHOR-Train-6758.scene_instance.json", + "./8/ProcTHOR-Train-6484.scene_instance.json", + "./8/ProcTHOR-Train-6482.scene_instance.json", + "./8/ProcTHOR-Train-6419.scene_instance.json", + "./8/ProcTHOR-Train-6959.scene_instance.json", + "./8/ProcTHOR-Train-6489.scene_instance.json", + "./8/ProcTHOR-Train-6504.scene_instance.json", + "./8/ProcTHOR-Train-6356.scene_instance.json", + "./8/ProcTHOR-Train-6091.scene_instance.json", + "./8/ProcTHOR-Train-6847.scene_instance.json", + "./8/ProcTHOR-Train-6250.scene_instance.json", + "./8/ProcTHOR-Train-6339.scene_instance.json", + "./8/ProcTHOR-Train-6270.scene_instance.json", + "./8/ProcTHOR-Train-6282.scene_instance.json", + "./8/ProcTHOR-Train-6675.scene_instance.json", + "./8/ProcTHOR-Train-6547.scene_instance.json", + "./8/ProcTHOR-Train-6238.scene_instance.json", + "./8/ProcTHOR-Train-6362.scene_instance.json", + "./8/ProcTHOR-Train-6143.scene_instance.json", + "./8/ProcTHOR-Train-6734.scene_instance.json", + "./8/ProcTHOR-Train-6325.scene_instance.json", + "./8/ProcTHOR-Train-6469.scene_instance.json", + "./8/ProcTHOR-Train-6646.scene_instance.json", + "./8/ProcTHOR-Train-6457.scene_instance.json", + "./8/ProcTHOR-Train-6348.scene_instance.json", + "./8/ProcTHOR-Train-6850.scene_instance.json", + "./8/ProcTHOR-Train-6186.scene_instance.json", + "./8/ProcTHOR-Train-6195.scene_instance.json", + "./8/ProcTHOR-Train-6022.scene_instance.json", + "./8/ProcTHOR-Train-6936.scene_instance.json", + "./8/ProcTHOR-Train-6305.scene_instance.json", + "./8/ProcTHOR-Train-6375.scene_instance.json", + "./8/ProcTHOR-Train-6267.scene_instance.json", + "./8/ProcTHOR-Train-6251.scene_instance.json", + "./8/ProcTHOR-Train-6076.scene_instance.json", + "./8/ProcTHOR-Train-6854.scene_instance.json", + "./8/ProcTHOR-Train-6035.scene_instance.json", + "./8/ProcTHOR-Train-6641.scene_instance.json", + "./8/ProcTHOR-Train-6381.scene_instance.json", + "./8/ProcTHOR-Train-6891.scene_instance.json", + "./8/ProcTHOR-Train-6324.scene_instance.json", + "./8/ProcTHOR-Train-6845.scene_instance.json", + "./8/ProcTHOR-Train-6730.scene_instance.json", + "./8/ProcTHOR-Train-6738.scene_instance.json", + "./8/ProcTHOR-Train-6781.scene_instance.json", + "./8/ProcTHOR-Train-6525.scene_instance.json", + "./8/ProcTHOR-Train-6686.scene_instance.json", + "./8/ProcTHOR-Train-6259.scene_instance.json", + "./8/ProcTHOR-Train-6950.scene_instance.json", + "./8/ProcTHOR-Train-6600.scene_instance.json", + "./8/ProcTHOR-Train-6271.scene_instance.json", + "./8/ProcTHOR-Train-6965.scene_instance.json", + "./8/ProcTHOR-Train-6906.scene_instance.json", + "./8/ProcTHOR-Train-6778.scene_instance.json", + "./8/ProcTHOR-Train-6056.scene_instance.json", + "./8/ProcTHOR-Train-6626.scene_instance.json", + "./8/ProcTHOR-Train-6587.scene_instance.json", + "./8/ProcTHOR-Train-6399.scene_instance.json", + "./8/ProcTHOR-Train-6061.scene_instance.json", + "./8/ProcTHOR-Train-6620.scene_instance.json", + "./8/ProcTHOR-Train-6934.scene_instance.json", + "./8/ProcTHOR-Train-6865.scene_instance.json", + "./8/ProcTHOR-Train-6300.scene_instance.json", + "./8/ProcTHOR-Train-6929.scene_instance.json", + "./8/ProcTHOR-Train-6643.scene_instance.json", + "./8/ProcTHOR-Train-6172.scene_instance.json", + "./8/ProcTHOR-Train-6940.scene_instance.json", + "./8/ProcTHOR-Train-6063.scene_instance.json", + "./8/ProcTHOR-Train-6429.scene_instance.json", + "./8/ProcTHOR-Train-6013.scene_instance.json", + "./8/ProcTHOR-Train-6790.scene_instance.json", + "./8/ProcTHOR-Train-6631.scene_instance.json", + "./8/ProcTHOR-Train-6239.scene_instance.json", + "./8/ProcTHOR-Train-6970.scene_instance.json", + "./8/ProcTHOR-Train-6123.scene_instance.json", + "./8/ProcTHOR-Train-6436.scene_instance.json", + "./8/ProcTHOR-Train-6543.scene_instance.json", + "./8/ProcTHOR-Train-6842.scene_instance.json", + "./8/ProcTHOR-Train-6597.scene_instance.json", + "./8/ProcTHOR-Train-6980.scene_instance.json", + "./8/ProcTHOR-Train-6364.scene_instance.json", + "./8/ProcTHOR-Train-6494.scene_instance.json", + "./8/ProcTHOR-Train-6475.scene_instance.json", + "./8/ProcTHOR-Train-6150.scene_instance.json", + "./8/ProcTHOR-Train-6993.scene_instance.json", + "./8/ProcTHOR-Train-6100.scene_instance.json", + "./8/ProcTHOR-Train-6807.scene_instance.json", + "./8/ProcTHOR-Train-6414.scene_instance.json", + "./8/ProcTHOR-Train-6910.scene_instance.json", + "./8/ProcTHOR-Train-6317.scene_instance.json", + "./8/ProcTHOR-Train-6677.scene_instance.json", + "./8/ProcTHOR-Train-6137.scene_instance.json", + "./8/ProcTHOR-Train-6310.scene_instance.json", + "./8/ProcTHOR-Train-6280.scene_instance.json", + "./8/ProcTHOR-Train-6464.scene_instance.json", + "./8/ProcTHOR-Train-6719.scene_instance.json", + "./8/ProcTHOR-Train-6777.scene_instance.json", + "./8/ProcTHOR-Train-6809.scene_instance.json", + "./8/ProcTHOR-Train-6692.scene_instance.json", + "./8/ProcTHOR-Train-6883.scene_instance.json", + "./8/ProcTHOR-Train-6681.scene_instance.json", + "./8/ProcTHOR-Train-6667.scene_instance.json", + "./8/ProcTHOR-Train-6110.scene_instance.json", + "./8/ProcTHOR-Train-6946.scene_instance.json", + "./8/ProcTHOR-Train-6795.scene_instance.json", + "./8/ProcTHOR-Train-6832.scene_instance.json", + "./8/ProcTHOR-Train-6047.scene_instance.json", + "./8/ProcTHOR-Train-6171.scene_instance.json", + "./8/ProcTHOR-Train-6816.scene_instance.json", + "./8/ProcTHOR-Train-6829.scene_instance.json", + "./8/ProcTHOR-Train-6084.scene_instance.json", + "./8/ProcTHOR-Train-6332.scene_instance.json", + "./8/ProcTHOR-Train-6798.scene_instance.json", + "./8/ProcTHOR-Train-6116.scene_instance.json", + "./8/ProcTHOR-Train-6820.scene_instance.json", + "./8/ProcTHOR-Train-6051.scene_instance.json", + "./8/ProcTHOR-Train-6350.scene_instance.json", + "./8/ProcTHOR-Train-6789.scene_instance.json", + "./8/ProcTHOR-Train-6733.scene_instance.json", + "./8/ProcTHOR-Train-6109.scene_instance.json", + "./8/ProcTHOR-Train-6748.scene_instance.json", + "./8/ProcTHOR-Train-6943.scene_instance.json", + "./8/ProcTHOR-Train-6103.scene_instance.json", + "./8/ProcTHOR-Train-6486.scene_instance.json", + "./8/ProcTHOR-Train-6955.scene_instance.json", + "./8/ProcTHOR-Train-6133.scene_instance.json", + "./8/ProcTHOR-Train-6224.scene_instance.json", + "./8/ProcTHOR-Train-6710.scene_instance.json", + "./8/ProcTHOR-Train-6296.scene_instance.json", + "./8/ProcTHOR-Train-6402.scene_instance.json", + "./8/ProcTHOR-Train-6997.scene_instance.json", + "./8/ProcTHOR-Train-6075.scene_instance.json", + "./8/ProcTHOR-Train-6594.scene_instance.json", + "./8/ProcTHOR-Train-6140.scene_instance.json", + "./8/ProcTHOR-Train-6700.scene_instance.json", + "./8/ProcTHOR-Train-6992.scene_instance.json", + "./8/ProcTHOR-Train-6507.scene_instance.json", + "./8/ProcTHOR-Train-6791.scene_instance.json", + "./8/ProcTHOR-Train-6688.scene_instance.json", + "./8/ProcTHOR-Train-6007.scene_instance.json", + "./8/ProcTHOR-Train-6156.scene_instance.json", + "./8/ProcTHOR-Train-6999.scene_instance.json", + "./8/ProcTHOR-Train-6624.scene_instance.json", + "./8/ProcTHOR-Train-6001.scene_instance.json", + "./8/ProcTHOR-Train-6444.scene_instance.json", + "./8/ProcTHOR-Train-6394.scene_instance.json", + "./8/ProcTHOR-Train-6159.scene_instance.json", + "./8/ProcTHOR-Train-6698.scene_instance.json", + "./8/ProcTHOR-Train-6960.scene_instance.json", + "./8/ProcTHOR-Train-6057.scene_instance.json", + "./8/ProcTHOR-Train-6755.scene_instance.json", + "./8/ProcTHOR-Train-6050.scene_instance.json", + "./8/ProcTHOR-Train-6514.scene_instance.json", + "./8/ProcTHOR-Train-6918.scene_instance.json", + "./8/ProcTHOR-Train-6564.scene_instance.json", + "./8/ProcTHOR-Train-6160.scene_instance.json", + "./8/ProcTHOR-Train-6966.scene_instance.json", + "./8/ProcTHOR-Train-6479.scene_instance.json", + "./8/ProcTHOR-Train-6948.scene_instance.json", + "./8/ProcTHOR-Train-6098.scene_instance.json", + "./8/ProcTHOR-Train-6395.scene_instance.json", + "./8/ProcTHOR-Train-6304.scene_instance.json", + "./8/ProcTHOR-Train-6299.scene_instance.json", + "./8/ProcTHOR-Train-6146.scene_instance.json", + "./8/ProcTHOR-Train-6278.scene_instance.json", + "./8/ProcTHOR-Train-6473.scene_instance.json", + "./8/ProcTHOR-Train-6701.scene_instance.json", + "./8/ProcTHOR-Train-6452.scene_instance.json", + "./8/ProcTHOR-Train-6254.scene_instance.json", + "./8/ProcTHOR-Train-6147.scene_instance.json", + "./8/ProcTHOR-Train-6215.scene_instance.json", + "./8/ProcTHOR-Train-6443.scene_instance.json", + "./8/ProcTHOR-Train-6291.scene_instance.json", + "./8/ProcTHOR-Train-6925.scene_instance.json", + "./8/ProcTHOR-Train-6009.scene_instance.json", + "./8/ProcTHOR-Train-6650.scene_instance.json", + "./8/ProcTHOR-Train-6344.scene_instance.json", + "./8/ProcTHOR-Train-6523.scene_instance.json", + "./8/ProcTHOR-Train-6046.scene_instance.json", + "./8/ProcTHOR-Train-6574.scene_instance.json", + "./8/ProcTHOR-Train-6593.scene_instance.json", + "./8/ProcTHOR-Train-6760.scene_instance.json", + "./8/ProcTHOR-Train-6465.scene_instance.json", + "./8/ProcTHOR-Train-6430.scene_instance.json", + "./8/ProcTHOR-Train-6074.scene_instance.json", + "./8/ProcTHOR-Train-6442.scene_instance.json", + "./8/ProcTHOR-Train-6125.scene_instance.json", + "./8/ProcTHOR-Train-6853.scene_instance.json", + "./8/ProcTHOR-Train-6202.scene_instance.json", + "./8/ProcTHOR-Train-6342.scene_instance.json", + "./8/ProcTHOR-Train-6839.scene_instance.json", + "./8/ProcTHOR-Train-6017.scene_instance.json", + "./8/ProcTHOR-Train-6029.scene_instance.json", + "./8/ProcTHOR-Train-6409.scene_instance.json", + "./8/ProcTHOR-Train-6954.scene_instance.json", + "./8/ProcTHOR-Train-6505.scene_instance.json", + "./8/ProcTHOR-Train-6708.scene_instance.json", + "./8/ProcTHOR-Train-6892.scene_instance.json", + "./8/ProcTHOR-Train-6988.scene_instance.json", + "./8/ProcTHOR-Train-6283.scene_instance.json", + "./8/ProcTHOR-Train-6222.scene_instance.json", + "./8/ProcTHOR-Train-6096.scene_instance.json", + "./8/ProcTHOR-Train-6828.scene_instance.json", + "./8/ProcTHOR-Train-6974.scene_instance.json", + "./8/ProcTHOR-Train-6927.scene_instance.json", + "./8/ProcTHOR-Train-6107.scene_instance.json", + "./8/ProcTHOR-Train-6384.scene_instance.json", + "./8/ProcTHOR-Train-6846.scene_instance.json", + "./8/ProcTHOR-Train-6145.scene_instance.json", + "./8/ProcTHOR-Train-6189.scene_instance.json", + "./8/ProcTHOR-Train-6969.scene_instance.json", + "./8/ProcTHOR-Train-6939.scene_instance.json", + "./8/ProcTHOR-Train-6289.scene_instance.json", + "./8/ProcTHOR-Train-6608.scene_instance.json", + "./8/ProcTHOR-Train-6311.scene_instance.json", + "./8/ProcTHOR-Train-6079.scene_instance.json", + "./8/ProcTHOR-Train-6642.scene_instance.json", + "./8/ProcTHOR-Train-6243.scene_instance.json", + "./8/ProcTHOR-Train-6553.scene_instance.json", + "./8/ProcTHOR-Train-6181.scene_instance.json", + "./8/ProcTHOR-Train-6272.scene_instance.json", + "./8/ProcTHOR-Train-6060.scene_instance.json", + "./8/ProcTHOR-Train-6244.scene_instance.json", + "./8/ProcTHOR-Train-6301.scene_instance.json", + "./8/ProcTHOR-Train-6577.scene_instance.json", + "./8/ProcTHOR-Train-6531.scene_instance.json", + "./8/ProcTHOR-Train-6453.scene_instance.json", + "./8/ProcTHOR-Train-6586.scene_instance.json", + "./8/ProcTHOR-Train-6139.scene_instance.json", + "./8/ProcTHOR-Train-6094.scene_instance.json", + "./8/ProcTHOR-Train-6601.scene_instance.json", + "./8/ProcTHOR-Train-6673.scene_instance.json", + "./8/ProcTHOR-Train-6068.scene_instance.json", + "./8/ProcTHOR-Train-6197.scene_instance.json", + "./8/ProcTHOR-Train-6230.scene_instance.json", + "./8/ProcTHOR-Train-6476.scene_instance.json", + "./8/ProcTHOR-Train-6717.scene_instance.json", + "./8/ProcTHOR-Train-6363.scene_instance.json", + "./8/ProcTHOR-Train-6422.scene_instance.json", + "./8/ProcTHOR-Train-6011.scene_instance.json", + "./8/ProcTHOR-Train-6290.scene_instance.json", + "./8/ProcTHOR-Train-6080.scene_instance.json", + "./8/ProcTHOR-Train-6963.scene_instance.json", + "./8/ProcTHOR-Train-6613.scene_instance.json", + "./8/ProcTHOR-Train-6086.scene_instance.json", + "./8/ProcTHOR-Train-6067.scene_instance.json", + "./8/ProcTHOR-Train-6596.scene_instance.json", + "./8/ProcTHOR-Train-6276.scene_instance.json", + "./8/ProcTHOR-Train-6053.scene_instance.json", + "./8/ProcTHOR-Train-6327.scene_instance.json", + "./8/ProcTHOR-Train-6245.scene_instance.json", + "./8/ProcTHOR-Train-6377.scene_instance.json", + "./8/ProcTHOR-Train-6223.scene_instance.json", + "./8/ProcTHOR-Train-6651.scene_instance.json", + "./8/ProcTHOR-Train-6724.scene_instance.json", + "./8/ProcTHOR-Train-6273.scene_instance.json", + "./8/ProcTHOR-Train-6403.scene_instance.json", + "./8/ProcTHOR-Train-6175.scene_instance.json", + "./8/ProcTHOR-Train-6648.scene_instance.json", + "./8/ProcTHOR-Train-6480.scene_instance.json", + "./8/ProcTHOR-Train-6491.scene_instance.json", + "./8/ProcTHOR-Train-6235.scene_instance.json", + "./8/ProcTHOR-Train-6210.scene_instance.json", + "./8/ProcTHOR-Train-6158.scene_instance.json", + "./8/ProcTHOR-Train-6699.scene_instance.json", + "./8/ProcTHOR-Train-6252.scene_instance.json", + "./8/ProcTHOR-Train-6218.scene_instance.json", + "./8/ProcTHOR-Train-6852.scene_instance.json", + "./8/ProcTHOR-Train-6506.scene_instance.json", + "./8/ProcTHOR-Train-6610.scene_instance.json", + "./8/ProcTHOR-Train-6303.scene_instance.json", + "./8/ProcTHOR-Train-6517.scene_instance.json", + "./8/ProcTHOR-Train-6014.scene_instance.json", + "./8/ProcTHOR-Train-6882.scene_instance.json", + "./8/ProcTHOR-Train-6831.scene_instance.json", + "./8/ProcTHOR-Train-6742.scene_instance.json", + "./8/ProcTHOR-Train-6365.scene_instance.json", + "./8/ProcTHOR-Train-6528.scene_instance.json", + "./8/ProcTHOR-Train-6867.scene_instance.json", + "./8/ProcTHOR-Train-6138.scene_instance.json", + "./8/ProcTHOR-Train-6353.scene_instance.json", + "./8/ProcTHOR-Train-6038.scene_instance.json", + "./8/ProcTHOR-Train-6380.scene_instance.json", + "./8/ProcTHOR-Train-6167.scene_instance.json", + "./8/ProcTHOR-Train-6321.scene_instance.json", + "./8/ProcTHOR-Train-6026.scene_instance.json", + "./8/ProcTHOR-Train-6287.scene_instance.json", + "./8/ProcTHOR-Train-6858.scene_instance.json", + "./8/ProcTHOR-Train-6930.scene_instance.json", + "./8/ProcTHOR-Train-6371.scene_instance.json", + "./8/ProcTHOR-Train-6049.scene_instance.json", + "./8/ProcTHOR-Train-6732.scene_instance.json", + "./8/ProcTHOR-Train-6511.scene_instance.json", + "./8/ProcTHOR-Train-6488.scene_instance.json", + "./8/ProcTHOR-Train-6378.scene_instance.json", + "./8/ProcTHOR-Train-6944.scene_instance.json", + "./8/ProcTHOR-Train-6345.scene_instance.json", + "./8/ProcTHOR-Train-6279.scene_instance.json", + "./8/ProcTHOR-Train-6603.scene_instance.json", + "./8/ProcTHOR-Train-6684.scene_instance.json", + "./8/ProcTHOR-Train-6275.scene_instance.json", + "./8/ProcTHOR-Train-6591.scene_instance.json", + "./8/ProcTHOR-Train-6101.scene_instance.json", + "./8/ProcTHOR-Train-6023.scene_instance.json", + "./8/ProcTHOR-Train-6977.scene_instance.json", + "./8/ProcTHOR-Train-6021.scene_instance.json", + "./8/ProcTHOR-Train-6148.scene_instance.json", + "./8/ProcTHOR-Train-6690.scene_instance.json", + "./8/ProcTHOR-Train-6949.scene_instance.json", + "./8/ProcTHOR-Train-6915.scene_instance.json", + "./8/ProcTHOR-Train-6689.scene_instance.json", + "./8/ProcTHOR-Train-6662.scene_instance.json", + "./8/ProcTHOR-Train-6548.scene_instance.json", + "./8/ProcTHOR-Train-6602.scene_instance.json", + "./8/ProcTHOR-Train-6647.scene_instance.json", + "./8/ProcTHOR-Train-6995.scene_instance.json", + "./8/ProcTHOR-Train-6765.scene_instance.json", + "./8/ProcTHOR-Train-6571.scene_instance.json", + "./8/ProcTHOR-Train-6658.scene_instance.json", + "./8/ProcTHOR-Train-6844.scene_instance.json", + "./8/ProcTHOR-Train-6233.scene_instance.json", + "./8/ProcTHOR-Train-6448.scene_instance.json", + "./8/ProcTHOR-Train-6155.scene_instance.json", + "./8/ProcTHOR-Train-6073.scene_instance.json", + "./8/ProcTHOR-Train-6801.scene_instance.json", + "./8/ProcTHOR-Train-6229.scene_instance.json", + "./8/ProcTHOR-Train-6567.scene_instance.json", + "./8/ProcTHOR-Train-6618.scene_instance.json", + "./8/ProcTHOR-Train-6634.scene_instance.json", + "./8/ProcTHOR-Train-6885.scene_instance.json", + "./8/ProcTHOR-Train-6952.scene_instance.json", + "./8/ProcTHOR-Train-6763.scene_instance.json", + "./8/ProcTHOR-Train-6292.scene_instance.json", + "./8/ProcTHOR-Train-6985.scene_instance.json", + "./8/ProcTHOR-Train-6256.scene_instance.json", + "./8/ProcTHOR-Train-6003.scene_instance.json", + "./8/ProcTHOR-Train-6640.scene_instance.json", + "./8/ProcTHOR-Train-6474.scene_instance.json", + "./8/ProcTHOR-Train-6043.scene_instance.json", + "./8/ProcTHOR-Train-6451.scene_instance.json", + "./8/ProcTHOR-Train-6417.scene_instance.json", + "./8/ProcTHOR-Train-6426.scene_instance.json", + "./8/ProcTHOR-Train-6697.scene_instance.json", + "./8/ProcTHOR-Train-6544.scene_instance.json", + "./8/ProcTHOR-Train-6707.scene_instance.json", + "./8/ProcTHOR-Train-6105.scene_instance.json", + "./8/ProcTHOR-Train-6588.scene_instance.json", + "./8/ProcTHOR-Train-6769.scene_instance.json", + "./8/ProcTHOR-Train-6042.scene_instance.json", + "./8/ProcTHOR-Train-6340.scene_instance.json", + "./8/ProcTHOR-Train-6621.scene_instance.json", + "./8/ProcTHOR-Train-6762.scene_instance.json", + "./8/ProcTHOR-Train-6996.scene_instance.json", + "./8/ProcTHOR-Train-6383.scene_instance.json", + "./8/ProcTHOR-Train-6445.scene_instance.json", + "./8/ProcTHOR-Train-6369.scene_instance.json", + "./8/ProcTHOR-Train-6661.scene_instance.json", + "./8/ProcTHOR-Train-6153.scene_instance.json", + "./8/ProcTHOR-Train-6415.scene_instance.json", + "./8/ProcTHOR-Train-6392.scene_instance.json", + "./8/ProcTHOR-Train-6122.scene_instance.json", + "./8/ProcTHOR-Train-6869.scene_instance.json", + "./8/ProcTHOR-Train-6926.scene_instance.json", + "./8/ProcTHOR-Train-6059.scene_instance.json", + "./8/ProcTHOR-Train-6260.scene_instance.json", + "./8/ProcTHOR-Train-6503.scene_instance.json", + "./8/ProcTHOR-Train-6487.scene_instance.json", + "./8/ProcTHOR-Train-6307.scene_instance.json", + "./8/ProcTHOR-Train-6794.scene_instance.json", + "./8/ProcTHOR-Train-6863.scene_instance.json", + "./8/ProcTHOR-Train-6257.scene_instance.json", + "./8/ProcTHOR-Train-6838.scene_instance.json", + "./8/ProcTHOR-Train-6458.scene_instance.json", + "./8/ProcTHOR-Train-6211.scene_instance.json", + "./8/ProcTHOR-Train-6645.scene_instance.json", + "./8/ProcTHOR-Train-6389.scene_instance.json", + "./8/ProcTHOR-Train-6671.scene_instance.json", + "./8/ProcTHOR-Train-6463.scene_instance.json", + "./8/ProcTHOR-Train-6097.scene_instance.json", + "./8/ProcTHOR-Train-6785.scene_instance.json", + "./8/ProcTHOR-Train-6932.scene_instance.json", + "./8/ProcTHOR-Train-6483.scene_instance.json", + "./8/ProcTHOR-Train-6644.scene_instance.json", + "./8/ProcTHOR-Train-6204.scene_instance.json", + "./8/ProcTHOR-Train-6903.scene_instance.json", + "./8/ProcTHOR-Train-6805.scene_instance.json", + "./8/ProcTHOR-Train-6532.scene_instance.json", + "./8/ProcTHOR-Train-6652.scene_instance.json", + "./8/ProcTHOR-Train-6581.scene_instance.json", + "./8/ProcTHOR-Train-6366.scene_instance.json", + "./8/ProcTHOR-Train-6286.scene_instance.json", + "./8/ProcTHOR-Train-6585.scene_instance.json", + "./8/ProcTHOR-Train-6066.scene_instance.json", + "./8/ProcTHOR-Train-6308.scene_instance.json", + "./8/ProcTHOR-Train-6087.scene_instance.json", + "./8/ProcTHOR-Train-6434.scene_instance.json", + "./8/ProcTHOR-Train-6556.scene_instance.json", + "./8/ProcTHOR-Train-6868.scene_instance.json", + "./8/ProcTHOR-Train-6534.scene_instance.json", + "./8/ProcTHOR-Train-6638.scene_instance.json", + "./8/ProcTHOR-Train-6680.scene_instance.json", + "./8/ProcTHOR-Train-6546.scene_instance.json", + "./8/ProcTHOR-Train-6316.scene_instance.json", + "./8/ProcTHOR-Train-6232.scene_instance.json", + "./8/ProcTHOR-Train-6037.scene_instance.json", + "./8/ProcTHOR-Train-6030.scene_instance.json", + "./8/ProcTHOR-Train-6835.scene_instance.json", + "./8/ProcTHOR-Train-6334.scene_instance.json", + "./8/ProcTHOR-Train-6269.scene_instance.json", + "./8/ProcTHOR-Train-6439.scene_instance.json", + "./8/ProcTHOR-Train-6951.scene_instance.json", + "./8/ProcTHOR-Train-6872.scene_instance.json", + "./8/ProcTHOR-Train-6036.scene_instance.json", + "./8/ProcTHOR-Train-6106.scene_instance.json", + "./8/ProcTHOR-Train-6878.scene_instance.json", + "./8/ProcTHOR-Train-6956.scene_instance.json", + "./8/ProcTHOR-Train-6569.scene_instance.json", + "./8/ProcTHOR-Train-6540.scene_instance.json", + "./8/ProcTHOR-Train-6655.scene_instance.json", + "./8/ProcTHOR-Train-6379.scene_instance.json", + "./8/ProcTHOR-Train-6217.scene_instance.json", + "./8/ProcTHOR-Train-6131.scene_instance.json", + "./8/ProcTHOR-Train-6431.scene_instance.json", + "./8/ProcTHOR-Train-6370.scene_instance.json", + "./8/ProcTHOR-Train-6368.scene_instance.json", + "./8/ProcTHOR-Train-6911.scene_instance.json", + "./8/ProcTHOR-Train-6117.scene_instance.json", + "./8/ProcTHOR-Train-6349.scene_instance.json", + "./8/ProcTHOR-Train-6508.scene_instance.json", + "./8/ProcTHOR-Train-6425.scene_instance.json", + "./8/ProcTHOR-Train-6792.scene_instance.json", + "./8/ProcTHOR-Train-6082.scene_instance.json", + "./8/ProcTHOR-Train-6541.scene_instance.json", + "./8/ProcTHOR-Train-6826.scene_instance.json", + "./8/ProcTHOR-Train-6678.scene_instance.json", + "./8/ProcTHOR-Train-6499.scene_instance.json", + "./3/ProcTHOR-Train-1579.scene_instance.json", + "./3/ProcTHOR-Train-1409.scene_instance.json", + "./3/ProcTHOR-Train-1395.scene_instance.json", + "./3/ProcTHOR-Train-1100.scene_instance.json", + "./3/ProcTHOR-Train-1294.scene_instance.json", + "./3/ProcTHOR-Train-1283.scene_instance.json", + "./3/ProcTHOR-Train-1443.scene_instance.json", + "./3/ProcTHOR-Train-1485.scene_instance.json", + "./3/ProcTHOR-Train-1569.scene_instance.json", + "./3/ProcTHOR-Train-1820.scene_instance.json", + "./3/ProcTHOR-Train-1236.scene_instance.json", + "./3/ProcTHOR-Train-1722.scene_instance.json", + "./3/ProcTHOR-Train-1913.scene_instance.json", + "./3/ProcTHOR-Train-1560.scene_instance.json", + "./3/ProcTHOR-Train-1027.scene_instance.json", + "./3/ProcTHOR-Train-1614.scene_instance.json", + "./3/ProcTHOR-Train-1053.scene_instance.json", + "./3/ProcTHOR-Train-1391.scene_instance.json", + "./3/ProcTHOR-Train-1339.scene_instance.json", + "./3/ProcTHOR-Train-1862.scene_instance.json", + "./3/ProcTHOR-Train-1271.scene_instance.json", + "./3/ProcTHOR-Train-1404.scene_instance.json", + "./3/ProcTHOR-Train-1065.scene_instance.json", + "./3/ProcTHOR-Train-1615.scene_instance.json", + "./3/ProcTHOR-Train-1344.scene_instance.json", + "./3/ProcTHOR-Train-1537.scene_instance.json", + "./3/ProcTHOR-Train-1979.scene_instance.json", + "./3/ProcTHOR-Train-1946.scene_instance.json", + "./3/ProcTHOR-Train-1276.scene_instance.json", + "./3/ProcTHOR-Train-1957.scene_instance.json", + "./3/ProcTHOR-Train-1244.scene_instance.json", + "./3/ProcTHOR-Train-1438.scene_instance.json", + "./3/ProcTHOR-Train-1256.scene_instance.json", + "./3/ProcTHOR-Train-1188.scene_instance.json", + "./3/ProcTHOR-Train-1030.scene_instance.json", + "./3/ProcTHOR-Train-1266.scene_instance.json", + "./3/ProcTHOR-Train-1734.scene_instance.json", + "./3/ProcTHOR-Train-1559.scene_instance.json", + "./3/ProcTHOR-Train-1845.scene_instance.json", + "./3/ProcTHOR-Train-1591.scene_instance.json", + "./3/ProcTHOR-Train-1394.scene_instance.json", + "./3/ProcTHOR-Train-1200.scene_instance.json", + "./3/ProcTHOR-Train-1516.scene_instance.json", + "./3/ProcTHOR-Train-1038.scene_instance.json", + "./3/ProcTHOR-Train-1154.scene_instance.json", + "./3/ProcTHOR-Train-1741.scene_instance.json", + "./3/ProcTHOR-Train-1783.scene_instance.json", + "./3/ProcTHOR-Train-1755.scene_instance.json", + "./3/ProcTHOR-Train-1933.scene_instance.json", + "./3/ProcTHOR-Train-1393.scene_instance.json", + "./3/ProcTHOR-Train-1920.scene_instance.json", + "./3/ProcTHOR-Train-1309.scene_instance.json", + "./3/ProcTHOR-Train-1896.scene_instance.json", + "./3/ProcTHOR-Train-1196.scene_instance.json", + "./3/ProcTHOR-Train-1014.scene_instance.json", + "./3/ProcTHOR-Train-1748.scene_instance.json", + "./3/ProcTHOR-Train-1936.scene_instance.json", + "./3/ProcTHOR-Train-1009.scene_instance.json", + "./3/ProcTHOR-Train-1634.scene_instance.json", + "./3/ProcTHOR-Train-1795.scene_instance.json", + "./3/ProcTHOR-Train-1017.scene_instance.json", + "./3/ProcTHOR-Train-1400.scene_instance.json", + "./3/ProcTHOR-Train-1824.scene_instance.json", + "./3/ProcTHOR-Train-1965.scene_instance.json", + "./3/ProcTHOR-Train-1430.scene_instance.json", + "./3/ProcTHOR-Train-1453.scene_instance.json", + "./3/ProcTHOR-Train-1517.scene_instance.json", + "./3/ProcTHOR-Train-1125.scene_instance.json", + "./3/ProcTHOR-Train-1180.scene_instance.json", + "./3/ProcTHOR-Train-1090.scene_instance.json", + "./3/ProcTHOR-Train-1799.scene_instance.json", + "./3/ProcTHOR-Train-1057.scene_instance.json", + "./3/ProcTHOR-Train-1060.scene_instance.json", + "./3/ProcTHOR-Train-1462.scene_instance.json", + "./3/ProcTHOR-Train-1306.scene_instance.json", + "./3/ProcTHOR-Train-1753.scene_instance.json", + "./3/ProcTHOR-Train-1003.scene_instance.json", + "./3/ProcTHOR-Train-1416.scene_instance.json", + "./3/ProcTHOR-Train-1767.scene_instance.json", + "./3/ProcTHOR-Train-1607.scene_instance.json", + "./3/ProcTHOR-Train-1937.scene_instance.json", + "./3/ProcTHOR-Train-1222.scene_instance.json", + "./3/ProcTHOR-Train-1801.scene_instance.json", + "./3/ProcTHOR-Train-1659.scene_instance.json", + "./3/ProcTHOR-Train-1818.scene_instance.json", + "./3/ProcTHOR-Train-1636.scene_instance.json", + "./3/ProcTHOR-Train-1495.scene_instance.json", + "./3/ProcTHOR-Train-1709.scene_instance.json", + "./3/ProcTHOR-Train-1474.scene_instance.json", + "./3/ProcTHOR-Train-1351.scene_instance.json", + "./3/ProcTHOR-Train-1596.scene_instance.json", + "./3/ProcTHOR-Train-1898.scene_instance.json", + "./3/ProcTHOR-Train-1715.scene_instance.json", + "./3/ProcTHOR-Train-1764.scene_instance.json", + "./3/ProcTHOR-Train-1550.scene_instance.json", + "./3/ProcTHOR-Train-1642.scene_instance.json", + "./3/ProcTHOR-Train-1934.scene_instance.json", + "./3/ProcTHOR-Train-1716.scene_instance.json", + "./3/ProcTHOR-Train-1770.scene_instance.json", + "./3/ProcTHOR-Train-1144.scene_instance.json", + "./3/ProcTHOR-Train-1227.scene_instance.json", + "./3/ProcTHOR-Train-1261.scene_instance.json", + "./3/ProcTHOR-Train-1525.scene_instance.json", + "./3/ProcTHOR-Train-1037.scene_instance.json", + "./3/ProcTHOR-Train-1426.scene_instance.json", + "./3/ProcTHOR-Train-1448.scene_instance.json", + "./3/ProcTHOR-Train-1215.scene_instance.json", + "./3/ProcTHOR-Train-1257.scene_instance.json", + "./3/ProcTHOR-Train-1303.scene_instance.json", + "./3/ProcTHOR-Train-1210.scene_instance.json", + "./3/ProcTHOR-Train-1844.scene_instance.json", + "./3/ProcTHOR-Train-1671.scene_instance.json", + "./3/ProcTHOR-Train-1839.scene_instance.json", + "./3/ProcTHOR-Train-1657.scene_instance.json", + "./3/ProcTHOR-Train-1547.scene_instance.json", + "./3/ProcTHOR-Train-1193.scene_instance.json", + "./3/ProcTHOR-Train-1892.scene_instance.json", + "./3/ProcTHOR-Train-1714.scene_instance.json", + "./3/ProcTHOR-Train-1768.scene_instance.json", + "./3/ProcTHOR-Train-1858.scene_instance.json", + "./3/ProcTHOR-Train-1745.scene_instance.json", + "./3/ProcTHOR-Train-1895.scene_instance.json", + "./3/ProcTHOR-Train-1891.scene_instance.json", + "./3/ProcTHOR-Train-1984.scene_instance.json", + "./3/ProcTHOR-Train-1618.scene_instance.json", + "./3/ProcTHOR-Train-1326.scene_instance.json", + "./3/ProcTHOR-Train-1015.scene_instance.json", + "./3/ProcTHOR-Train-1417.scene_instance.json", + "./3/ProcTHOR-Train-1797.scene_instance.json", + "./3/ProcTHOR-Train-1930.scene_instance.json", + "./3/ProcTHOR-Train-1088.scene_instance.json", + "./3/ProcTHOR-Train-1903.scene_instance.json", + "./3/ProcTHOR-Train-1928.scene_instance.json", + "./3/ProcTHOR-Train-1990.scene_instance.json", + "./3/ProcTHOR-Train-1432.scene_instance.json", + "./3/ProcTHOR-Train-1905.scene_instance.json", + "./3/ProcTHOR-Train-1148.scene_instance.json", + "./3/ProcTHOR-Train-1581.scene_instance.json", + "./3/ProcTHOR-Train-1688.scene_instance.json", + "./3/ProcTHOR-Train-1446.scene_instance.json", + "./3/ProcTHOR-Train-1625.scene_instance.json", + "./3/ProcTHOR-Train-1099.scene_instance.json", + "./3/ProcTHOR-Train-1237.scene_instance.json", + "./3/ProcTHOR-Train-1598.scene_instance.json", + "./3/ProcTHOR-Train-1483.scene_instance.json", + "./3/ProcTHOR-Train-1445.scene_instance.json", + "./3/ProcTHOR-Train-1627.scene_instance.json", + "./3/ProcTHOR-Train-1026.scene_instance.json", + "./3/ProcTHOR-Train-1123.scene_instance.json", + "./3/ProcTHOR-Train-1731.scene_instance.json", + "./3/ProcTHOR-Train-1739.scene_instance.json", + "./3/ProcTHOR-Train-1374.scene_instance.json", + "./3/ProcTHOR-Train-1376.scene_instance.json", + "./3/ProcTHOR-Train-1211.scene_instance.json", + "./3/ProcTHOR-Train-1220.scene_instance.json", + "./3/ProcTHOR-Train-1623.scene_instance.json", + "./3/ProcTHOR-Train-1854.scene_instance.json", + "./3/ProcTHOR-Train-1419.scene_instance.json", + "./3/ProcTHOR-Train-1983.scene_instance.json", + "./3/ProcTHOR-Train-1084.scene_instance.json", + "./3/ProcTHOR-Train-1422.scene_instance.json", + "./3/ProcTHOR-Train-1134.scene_instance.json", + "./3/ProcTHOR-Train-1630.scene_instance.json", + "./3/ProcTHOR-Train-1186.scene_instance.json", + "./3/ProcTHOR-Train-1073.scene_instance.json", + "./3/ProcTHOR-Train-1005.scene_instance.json", + "./3/ProcTHOR-Train-1039.scene_instance.json", + "./3/ProcTHOR-Train-1054.scene_instance.json", + "./3/ProcTHOR-Train-1563.scene_instance.json", + "./3/ProcTHOR-Train-1347.scene_instance.json", + "./3/ProcTHOR-Train-1286.scene_instance.json", + "./3/ProcTHOR-Train-1016.scene_instance.json", + "./3/ProcTHOR-Train-1383.scene_instance.json", + "./3/ProcTHOR-Train-1897.scene_instance.json", + "./3/ProcTHOR-Train-1397.scene_instance.json", + "./3/ProcTHOR-Train-1301.scene_instance.json", + "./3/ProcTHOR-Train-1989.scene_instance.json", + "./3/ProcTHOR-Train-1691.scene_instance.json", + "./3/ProcTHOR-Train-1031.scene_instance.json", + "./3/ProcTHOR-Train-1872.scene_instance.json", + "./3/ProcTHOR-Train-1935.scene_instance.json", + "./3/ProcTHOR-Train-1083.scene_instance.json", + "./3/ProcTHOR-Train-1164.scene_instance.json", + "./3/ProcTHOR-Train-1793.scene_instance.json", + "./3/ProcTHOR-Train-1830.scene_instance.json", + "./3/ProcTHOR-Train-1522.scene_instance.json", + "./3/ProcTHOR-Train-1779.scene_instance.json", + "./3/ProcTHOR-Train-1087.scene_instance.json", + "./3/ProcTHOR-Train-1603.scene_instance.json", + "./3/ProcTHOR-Train-1141.scene_instance.json", + "./3/ProcTHOR-Train-1182.scene_instance.json", + "./3/ProcTHOR-Train-1034.scene_instance.json", + "./3/ProcTHOR-Train-1703.scene_instance.json", + "./3/ProcTHOR-Train-1951.scene_instance.json", + "./3/ProcTHOR-Train-1698.scene_instance.json", + "./3/ProcTHOR-Train-1619.scene_instance.json", + "./3/ProcTHOR-Train-1372.scene_instance.json", + "./3/ProcTHOR-Train-1336.scene_instance.json", + "./3/ProcTHOR-Train-1789.scene_instance.json", + "./3/ProcTHOR-Train-1059.scene_instance.json", + "./3/ProcTHOR-Train-1804.scene_instance.json", + "./3/ProcTHOR-Train-1860.scene_instance.json", + "./3/ProcTHOR-Train-1997.scene_instance.json", + "./3/ProcTHOR-Train-1333.scene_instance.json", + "./3/ProcTHOR-Train-1129.scene_instance.json", + "./3/ProcTHOR-Train-1843.scene_instance.json", + "./3/ProcTHOR-Train-1865.scene_instance.json", + "./3/ProcTHOR-Train-1385.scene_instance.json", + "./3/ProcTHOR-Train-1218.scene_instance.json", + "./3/ProcTHOR-Train-1851.scene_instance.json", + "./3/ProcTHOR-Train-1549.scene_instance.json", + "./3/ProcTHOR-Train-1730.scene_instance.json", + "./3/ProcTHOR-Train-1452.scene_instance.json", + "./3/ProcTHOR-Train-1864.scene_instance.json", + "./3/ProcTHOR-Train-1108.scene_instance.json", + "./3/ProcTHOR-Train-1370.scene_instance.json", + "./3/ProcTHOR-Train-1420.scene_instance.json", + "./3/ProcTHOR-Train-1686.scene_instance.json", + "./3/ProcTHOR-Train-1959.scene_instance.json", + "./3/ProcTHOR-Train-1693.scene_instance.json", + "./3/ProcTHOR-Train-1177.scene_instance.json", + "./3/ProcTHOR-Train-1354.scene_instance.json", + "./3/ProcTHOR-Train-1000.scene_instance.json", + "./3/ProcTHOR-Train-1539.scene_instance.json", + "./3/ProcTHOR-Train-1431.scene_instance.json", + "./3/ProcTHOR-Train-1317.scene_instance.json", + "./3/ProcTHOR-Train-1273.scene_instance.json", + "./3/ProcTHOR-Train-1380.scene_instance.json", + "./3/ProcTHOR-Train-1694.scene_instance.json", + "./3/ProcTHOR-Train-1136.scene_instance.json", + "./3/ProcTHOR-Train-1999.scene_instance.json", + "./3/ProcTHOR-Train-1106.scene_instance.json", + "./3/ProcTHOR-Train-1637.scene_instance.json", + "./3/ProcTHOR-Train-1170.scene_instance.json", + "./3/ProcTHOR-Train-1367.scene_instance.json", + "./3/ProcTHOR-Train-1068.scene_instance.json", + "./3/ProcTHOR-Train-1158.scene_instance.json", + "./3/ProcTHOR-Train-1679.scene_instance.json", + "./3/ProcTHOR-Train-1599.scene_instance.json", + "./3/ProcTHOR-Train-1792.scene_instance.json", + "./3/ProcTHOR-Train-1582.scene_instance.json", + "./3/ProcTHOR-Train-1805.scene_instance.json", + "./3/ProcTHOR-Train-1922.scene_instance.json", + "./3/ProcTHOR-Train-1678.scene_instance.json", + "./3/ProcTHOR-Train-1859.scene_instance.json", + "./3/ProcTHOR-Train-1232.scene_instance.json", + "./3/ProcTHOR-Train-1230.scene_instance.json", + "./3/ProcTHOR-Train-1145.scene_instance.json", + "./3/ProcTHOR-Train-1624.scene_instance.json", + "./3/ProcTHOR-Train-1040.scene_instance.json", + "./3/ProcTHOR-Train-1201.scene_instance.json", + "./3/ProcTHOR-Train-1429.scene_instance.json", + "./3/ProcTHOR-Train-1194.scene_instance.json", + "./3/ProcTHOR-Train-1390.scene_instance.json", + "./3/ProcTHOR-Train-1377.scene_instance.json", + "./3/ProcTHOR-Train-1656.scene_instance.json", + "./3/ProcTHOR-Train-1982.scene_instance.json", + "./3/ProcTHOR-Train-1887.scene_instance.json", + "./3/ProcTHOR-Train-1081.scene_instance.json", + "./3/ProcTHOR-Train-1456.scene_instance.json", + "./3/ProcTHOR-Train-1504.scene_instance.json", + "./3/ProcTHOR-Train-1042.scene_instance.json", + "./3/ProcTHOR-Train-1701.scene_instance.json", + "./3/ProcTHOR-Train-1388.scene_instance.json", + "./3/ProcTHOR-Train-1756.scene_instance.json", + "./3/ProcTHOR-Train-1345.scene_instance.json", + "./3/ProcTHOR-Train-1809.scene_instance.json", + "./3/ProcTHOR-Train-1451.scene_instance.json", + "./3/ProcTHOR-Train-1978.scene_instance.json", + "./3/ProcTHOR-Train-1228.scene_instance.json", + "./3/ProcTHOR-Train-1724.scene_instance.json", + "./3/ProcTHOR-Train-1465.scene_instance.json", + "./3/ProcTHOR-Train-1969.scene_instance.json", + "./3/ProcTHOR-Train-1275.scene_instance.json", + "./3/ProcTHOR-Train-1778.scene_instance.json", + "./3/ProcTHOR-Train-1263.scene_instance.json", + "./3/ProcTHOR-Train-1185.scene_instance.json", + "./3/ProcTHOR-Train-1095.scene_instance.json", + "./3/ProcTHOR-Train-1594.scene_instance.json", + "./3/ProcTHOR-Train-1945.scene_instance.json", + "./3/ProcTHOR-Train-1652.scene_instance.json", + "./3/ProcTHOR-Train-1334.scene_instance.json", + "./3/ProcTHOR-Train-1519.scene_instance.json", + "./3/ProcTHOR-Train-1307.scene_instance.json", + "./3/ProcTHOR-Train-1890.scene_instance.json", + "./3/ProcTHOR-Train-1713.scene_instance.json", + "./3/ProcTHOR-Train-1171.scene_instance.json", + "./3/ProcTHOR-Train-1566.scene_instance.json", + "./3/ProcTHOR-Train-1454.scene_instance.json", + "./3/ProcTHOR-Train-1677.scene_instance.json", + "./3/ProcTHOR-Train-1685.scene_instance.json", + "./3/ProcTHOR-Train-1117.scene_instance.json", + "./3/ProcTHOR-Train-1708.scene_instance.json", + "./3/ProcTHOR-Train-1853.scene_instance.json", + "./3/ProcTHOR-Train-1330.scene_instance.json", + "./3/ProcTHOR-Train-1908.scene_instance.json", + "./3/ProcTHOR-Train-1288.scene_instance.json", + "./3/ProcTHOR-Train-1069.scene_instance.json", + "./3/ProcTHOR-Train-1894.scene_instance.json", + "./3/ProcTHOR-Train-1491.scene_instance.json", + "./3/ProcTHOR-Train-1041.scene_instance.json", + "./3/ProcTHOR-Train-1020.scene_instance.json", + "./3/ProcTHOR-Train-1704.scene_instance.json", + "./3/ProcTHOR-Train-1097.scene_instance.json", + "./3/ProcTHOR-Train-1361.scene_instance.json", + "./3/ProcTHOR-Train-1191.scene_instance.json", + "./3/ProcTHOR-Train-1492.scene_instance.json", + "./3/ProcTHOR-Train-1440.scene_instance.json", + "./3/ProcTHOR-Train-1710.scene_instance.json", + "./3/ProcTHOR-Train-1609.scene_instance.json", + "./3/ProcTHOR-Train-1075.scene_instance.json", + "./3/ProcTHOR-Train-1497.scene_instance.json", + "./3/ProcTHOR-Train-1331.scene_instance.json", + "./3/ProcTHOR-Train-1499.scene_instance.json", + "./3/ProcTHOR-Train-1124.scene_instance.json", + "./3/ProcTHOR-Train-1457.scene_instance.json", + "./3/ProcTHOR-Train-1842.scene_instance.json", + "./3/ProcTHOR-Train-1484.scene_instance.json", + "./3/ProcTHOR-Train-1225.scene_instance.json", + "./3/ProcTHOR-Train-1545.scene_instance.json", + "./3/ProcTHOR-Train-1863.scene_instance.json", + "./3/ProcTHOR-Train-1287.scene_instance.json", + "./3/ProcTHOR-Train-1785.scene_instance.json", + "./3/ProcTHOR-Train-1265.scene_instance.json", + "./3/ProcTHOR-Train-1318.scene_instance.json", + "./3/ProcTHOR-Train-1112.scene_instance.json", + "./3/ProcTHOR-Train-1500.scene_instance.json", + "./3/ProcTHOR-Train-1621.scene_instance.json", + "./3/ProcTHOR-Train-1312.scene_instance.json", + "./3/ProcTHOR-Train-1869.scene_instance.json", + "./3/ProcTHOR-Train-1202.scene_instance.json", + "./3/ProcTHOR-Train-1568.scene_instance.json", + "./3/ProcTHOR-Train-1403.scene_instance.json", + "./3/ProcTHOR-Train-1435.scene_instance.json", + "./3/ProcTHOR-Train-1954.scene_instance.json", + "./3/ProcTHOR-Train-1049.scene_instance.json", + "./3/ProcTHOR-Train-1883.scene_instance.json", + "./3/ProcTHOR-Train-1981.scene_instance.json", + "./3/ProcTHOR-Train-1381.scene_instance.json", + "./3/ProcTHOR-Train-1080.scene_instance.json", + "./3/ProcTHOR-Train-1157.scene_instance.json", + "./3/ProcTHOR-Train-1343.scene_instance.json", + "./3/ProcTHOR-Train-1358.scene_instance.json", + "./3/ProcTHOR-Train-1775.scene_instance.json", + "./3/ProcTHOR-Train-1173.scene_instance.json", + "./3/ProcTHOR-Train-1907.scene_instance.json", + "./3/ProcTHOR-Train-1142.scene_instance.json", + "./3/ProcTHOR-Train-1931.scene_instance.json", + "./3/ProcTHOR-Train-1113.scene_instance.json", + "./3/ProcTHOR-Train-1349.scene_instance.json", + "./3/ProcTHOR-Train-1641.scene_instance.json", + "./3/ProcTHOR-Train-1943.scene_instance.json", + "./3/ProcTHOR-Train-1278.scene_instance.json", + "./3/ProcTHOR-Train-1120.scene_instance.json", + "./3/ProcTHOR-Train-1562.scene_instance.json", + "./3/ProcTHOR-Train-1632.scene_instance.json", + "./3/ProcTHOR-Train-1592.scene_instance.json", + "./3/ProcTHOR-Train-1939.scene_instance.json", + "./3/ProcTHOR-Train-1321.scene_instance.json", + "./3/ProcTHOR-Train-1772.scene_instance.json", + "./3/ProcTHOR-Train-1736.scene_instance.json", + "./3/ProcTHOR-Train-1233.scene_instance.json", + "./3/ProcTHOR-Train-1613.scene_instance.json", + "./3/ProcTHOR-Train-1662.scene_instance.json", + "./3/ProcTHOR-Train-1602.scene_instance.json", + "./3/ProcTHOR-Train-1311.scene_instance.json", + "./3/ProcTHOR-Train-1647.scene_instance.json", + "./3/ProcTHOR-Train-1121.scene_instance.json", + "./3/ProcTHOR-Train-1974.scene_instance.json", + "./3/ProcTHOR-Train-1350.scene_instance.json", + "./3/ProcTHOR-Train-1085.scene_instance.json", + "./3/ProcTHOR-Train-1692.scene_instance.json", + "./3/ProcTHOR-Train-1425.scene_instance.json", + "./3/ProcTHOR-Train-1156.scene_instance.json", + "./3/ProcTHOR-Train-1784.scene_instance.json", + "./3/ProcTHOR-Train-1558.scene_instance.json", + "./3/ProcTHOR-Train-1503.scene_instance.json", + "./3/ProcTHOR-Train-1130.scene_instance.json", + "./3/ProcTHOR-Train-1212.scene_instance.json", + "./3/ProcTHOR-Train-1249.scene_instance.json", + "./3/ProcTHOR-Train-1178.scene_instance.json", + "./3/ProcTHOR-Train-1011.scene_instance.json", + "./3/ProcTHOR-Train-1699.scene_instance.json", + "./3/ProcTHOR-Train-1512.scene_instance.json", + "./3/ProcTHOR-Train-1682.scene_instance.json", + "./3/ProcTHOR-Train-1105.scene_instance.json", + "./3/ProcTHOR-Train-1513.scene_instance.json", + "./3/ProcTHOR-Train-1648.scene_instance.json", + "./3/ProcTHOR-Train-1183.scene_instance.json", + "./3/ProcTHOR-Train-1035.scene_instance.json", + "./3/ProcTHOR-Train-1092.scene_instance.json", + "./3/ProcTHOR-Train-1684.scene_instance.json", + "./3/ProcTHOR-Train-1114.scene_instance.json", + "./3/ProcTHOR-Train-1806.scene_instance.json", + "./3/ProcTHOR-Train-1365.scene_instance.json", + "./3/ProcTHOR-Train-1531.scene_instance.json", + "./3/ProcTHOR-Train-1850.scene_instance.json", + "./3/ProcTHOR-Train-1252.scene_instance.json", + "./3/ProcTHOR-Train-1788.scene_instance.json", + "./3/ProcTHOR-Train-1076.scene_instance.json", + "./3/ProcTHOR-Train-1338.scene_instance.json", + "./3/ProcTHOR-Train-1064.scene_instance.json", + "./3/ProcTHOR-Train-1612.scene_instance.json", + "./3/ProcTHOR-Train-1971.scene_instance.json", + "./3/ProcTHOR-Train-1094.scene_instance.json", + "./3/ProcTHOR-Train-1573.scene_instance.json", + "./3/ProcTHOR-Train-1479.scene_instance.json", + "./3/ProcTHOR-Train-1139.scene_instance.json", + "./3/ProcTHOR-Train-1101.scene_instance.json", + "./3/ProcTHOR-Train-1980.scene_instance.json", + "./3/ProcTHOR-Train-1575.scene_instance.json", + "./3/ProcTHOR-Train-1293.scene_instance.json", + "./3/ProcTHOR-Train-1248.scene_instance.json", + "./3/ProcTHOR-Train-1968.scene_instance.json", + "./3/ProcTHOR-Train-1281.scene_instance.json", + "./3/ProcTHOR-Train-1798.scene_instance.json", + "./3/ProcTHOR-Train-1750.scene_instance.json", + "./3/ProcTHOR-Train-1427.scene_instance.json", + "./3/ProcTHOR-Train-1135.scene_instance.json", + "./3/ProcTHOR-Train-1316.scene_instance.json", + "./3/ProcTHOR-Train-1006.scene_instance.json", + "./3/ProcTHOR-Train-1765.scene_instance.json", + "./3/ProcTHOR-Train-1802.scene_instance.json", + "./3/ProcTHOR-Train-1324.scene_instance.json", + "./3/ProcTHOR-Train-1520.scene_instance.json", + "./3/ProcTHOR-Train-1527.scene_instance.json", + "./3/ProcTHOR-Train-1258.scene_instance.json", + "./3/ProcTHOR-Train-1970.scene_instance.json", + "./3/ProcTHOR-Train-1511.scene_instance.json", + "./3/ProcTHOR-Train-1231.scene_instance.json", + "./3/ProcTHOR-Train-1901.scene_instance.json", + "./3/ProcTHOR-Train-1478.scene_instance.json", + "./3/ProcTHOR-Train-1923.scene_instance.json", + "./3/ProcTHOR-Train-1833.scene_instance.json", + "./3/ProcTHOR-Train-1468.scene_instance.json", + "./3/ProcTHOR-Train-1058.scene_instance.json", + "./3/ProcTHOR-Train-1110.scene_instance.json", + "./3/ProcTHOR-Train-1738.scene_instance.json", + "./3/ProcTHOR-Train-1849.scene_instance.json", + "./3/ProcTHOR-Train-1925.scene_instance.json", + "./3/ProcTHOR-Train-1664.scene_instance.json", + "./3/ProcTHOR-Train-1061.scene_instance.json", + "./3/ProcTHOR-Train-1717.scene_instance.json", + "./3/ProcTHOR-Train-1469.scene_instance.json", + "./3/ProcTHOR-Train-1586.scene_instance.json", + "./3/ProcTHOR-Train-1733.scene_instance.json", + "./3/ProcTHOR-Train-1538.scene_instance.json", + "./3/ProcTHOR-Train-1829.scene_instance.json", + "./3/ProcTHOR-Train-1199.scene_instance.json", + "./3/ProcTHOR-Train-1264.scene_instance.json", + "./3/ProcTHOR-Train-1557.scene_instance.json", + "./3/ProcTHOR-Train-1013.scene_instance.json", + "./3/ProcTHOR-Train-1852.scene_instance.json", + "./3/ProcTHOR-Train-1540.scene_instance.json", + "./3/ProcTHOR-Train-1423.scene_instance.json", + "./3/ProcTHOR-Train-1926.scene_instance.json", + "./3/ProcTHOR-Train-1992.scene_instance.json", + "./3/ProcTHOR-Train-1475.scene_instance.json", + "./3/ProcTHOR-Train-1277.scene_instance.json", + "./3/ProcTHOR-Train-1543.scene_instance.json", + "./3/ProcTHOR-Train-1213.scene_instance.json", + "./3/ProcTHOR-Train-1551.scene_instance.json", + "./3/ProcTHOR-Train-1629.scene_instance.json", + "./3/ProcTHOR-Train-1204.scene_instance.json", + "./3/ProcTHOR-Train-1109.scene_instance.json", + "./3/ProcTHOR-Train-1871.scene_instance.json", + "./3/ProcTHOR-Train-1292.scene_instance.json", + "./3/ProcTHOR-Train-1441.scene_instance.json", + "./3/ProcTHOR-Train-1509.scene_instance.json", + "./3/ProcTHOR-Train-1777.scene_instance.json", + "./3/ProcTHOR-Train-1335.scene_instance.json", + "./3/ProcTHOR-Train-1044.scene_instance.json", + "./3/ProcTHOR-Train-1267.scene_instance.json", + "./3/ProcTHOR-Train-1595.scene_instance.json", + "./3/ProcTHOR-Train-1780.scene_instance.json", + "./3/ProcTHOR-Train-1056.scene_instance.json", + "./3/ProcTHOR-Train-1867.scene_instance.json", + "./3/ProcTHOR-Train-1458.scene_instance.json", + "./3/ProcTHOR-Train-1762.scene_instance.json", + "./3/ProcTHOR-Train-1650.scene_instance.json", + "./3/ProcTHOR-Train-1414.scene_instance.json", + "./3/ProcTHOR-Train-1001.scene_instance.json", + "./3/ProcTHOR-Train-1800.scene_instance.json", + "./3/ProcTHOR-Train-1718.scene_instance.json", + "./3/ProcTHOR-Train-1238.scene_instance.json", + "./3/ProcTHOR-Train-1831.scene_instance.json", + "./3/ProcTHOR-Train-1757.scene_instance.json", + "./3/ProcTHOR-Train-1280.scene_instance.json", + "./3/ProcTHOR-Train-1161.scene_instance.json", + "./3/ProcTHOR-Train-1769.scene_instance.json", + "./3/ProcTHOR-Train-1024.scene_instance.json", + "./3/ProcTHOR-Train-1066.scene_instance.json", + "./3/ProcTHOR-Train-1921.scene_instance.json", + "./3/ProcTHOR-Train-1747.scene_instance.json", + "./3/ProcTHOR-Train-1195.scene_instance.json", + "./3/ProcTHOR-Train-1972.scene_instance.json", + "./3/ProcTHOR-Train-1742.scene_instance.json", + "./3/ProcTHOR-Train-1074.scene_instance.json", + "./3/ProcTHOR-Train-1147.scene_instance.json", + "./3/ProcTHOR-Train-1070.scene_instance.json", + "./3/ProcTHOR-Train-1043.scene_instance.json", + "./3/ProcTHOR-Train-1855.scene_instance.json", + "./3/ProcTHOR-Train-1460.scene_instance.json", + "./3/ProcTHOR-Train-1960.scene_instance.json", + "./3/ProcTHOR-Train-1949.scene_instance.json", + "./3/ProcTHOR-Train-1962.scene_instance.json", + "./3/ProcTHOR-Train-1363.scene_instance.json", + "./3/ProcTHOR-Train-1827.scene_instance.json", + "./3/ProcTHOR-Train-1216.scene_instance.json", + "./3/ProcTHOR-Train-1608.scene_instance.json", + "./3/ProcTHOR-Train-1305.scene_instance.json", + "./3/ProcTHOR-Train-1279.scene_instance.json", + "./3/ProcTHOR-Train-1274.scene_instance.json", + "./3/ProcTHOR-Train-1542.scene_instance.json", + "./3/ProcTHOR-Train-1418.scene_instance.json", + "./3/ProcTHOR-Train-1166.scene_instance.json", + "./3/ProcTHOR-Train-1379.scene_instance.json", + "./3/ProcTHOR-Train-1521.scene_instance.json", + "./3/ProcTHOR-Train-1814.scene_instance.json", + "./3/ProcTHOR-Train-1532.scene_instance.json", + "./3/ProcTHOR-Train-1224.scene_instance.json", + "./3/ProcTHOR-Train-1036.scene_instance.json", + "./3/ProcTHOR-Train-1529.scene_instance.json", + "./3/ProcTHOR-Train-1669.scene_instance.json", + "./3/ProcTHOR-Train-1687.scene_instance.json", + "./3/ProcTHOR-Train-1406.scene_instance.json", + "./3/ProcTHOR-Train-1496.scene_instance.json", + "./3/ProcTHOR-Train-1082.scene_instance.json", + "./3/ProcTHOR-Train-1179.scene_instance.json", + "./3/ProcTHOR-Train-1585.scene_instance.json", + "./3/ProcTHOR-Train-1348.scene_instance.json", + "./3/ProcTHOR-Train-1958.scene_instance.json", + "./3/ProcTHOR-Train-1877.scene_instance.json", + "./3/ProcTHOR-Train-1253.scene_instance.json", + "./3/ProcTHOR-Train-1359.scene_instance.json", + "./3/ProcTHOR-Train-1653.scene_instance.json", + "./3/ProcTHOR-Train-1340.scene_instance.json", + "./3/ProcTHOR-Train-1823.scene_instance.json", + "./3/ProcTHOR-Train-1405.scene_instance.json", + "./3/ProcTHOR-Train-1205.scene_instance.json", + "./3/ProcTHOR-Train-1683.scene_instance.json", + "./3/ProcTHOR-Train-1948.scene_instance.json", + "./3/ProcTHOR-Train-1588.scene_instance.json", + "./3/ProcTHOR-Train-1471.scene_instance.json", + "./3/ProcTHOR-Train-1941.scene_instance.json", + "./3/ProcTHOR-Train-1944.scene_instance.json", + "./3/ProcTHOR-Train-1410.scene_instance.json", + "./3/ProcTHOR-Train-1963.scene_instance.json", + "./3/ProcTHOR-Train-1706.scene_instance.json", + "./3/ProcTHOR-Train-1366.scene_instance.json", + "./3/ProcTHOR-Train-1528.scene_instance.json", + "./3/ProcTHOR-Train-1620.scene_instance.json", + "./3/ProcTHOR-Train-1675.scene_instance.json", + "./3/ProcTHOR-Train-1151.scene_instance.json", + "./3/ProcTHOR-Train-1515.scene_instance.json", + "./3/ProcTHOR-Train-1269.scene_instance.json", + "./3/ProcTHOR-Train-1665.scene_instance.json", + "./3/ProcTHOR-Train-1198.scene_instance.json", + "./3/ProcTHOR-Train-1737.scene_instance.json", + "./3/ProcTHOR-Train-1268.scene_instance.json", + "./3/ProcTHOR-Train-1813.scene_instance.json", + "./3/ProcTHOR-Train-1673.scene_instance.json", + "./3/ProcTHOR-Train-1728.scene_instance.json", + "./3/ProcTHOR-Train-1899.scene_instance.json", + "./3/ProcTHOR-Train-1098.scene_instance.json", + "./3/ProcTHOR-Train-1352.scene_instance.json", + "./3/ProcTHOR-Train-1203.scene_instance.json", + "./3/ProcTHOR-Train-1966.scene_instance.json", + "./3/ProcTHOR-Train-1482.scene_instance.json", + "./3/ProcTHOR-Train-1308.scene_instance.json", + "./3/ProcTHOR-Train-1927.scene_instance.json", + "./3/ProcTHOR-Train-1119.scene_instance.json", + "./3/ProcTHOR-Train-1985.scene_instance.json", + "./3/ProcTHOR-Train-1461.scene_instance.json", + "./3/ProcTHOR-Train-1616.scene_instance.json", + "./3/ProcTHOR-Train-1672.scene_instance.json", + "./3/ProcTHOR-Train-1254.scene_instance.json", + "./3/ProcTHOR-Train-1501.scene_instance.json", + "./3/ProcTHOR-Train-1240.scene_instance.json", + "./3/ProcTHOR-Train-1436.scene_instance.json", + "./3/ProcTHOR-Train-1356.scene_instance.json", + "./3/ProcTHOR-Train-1493.scene_instance.json", + "./3/ProcTHOR-Train-1902.scene_instance.json", + "./3/ProcTHOR-Train-1078.scene_instance.json", + "./3/ProcTHOR-Train-1219.scene_instance.json", + "./3/ProcTHOR-Train-1707.scene_instance.json", + "./3/ProcTHOR-Train-1617.scene_instance.json", + "./3/ProcTHOR-Train-1847.scene_instance.json", + "./3/ProcTHOR-Train-1995.scene_instance.json", + "./3/ProcTHOR-Train-1444.scene_instance.json", + "./3/ProcTHOR-Train-1489.scene_instance.json", + "./3/ProcTHOR-Train-1052.scene_instance.json", + "./3/ProcTHOR-Train-1645.scene_instance.json", + "./3/ProcTHOR-Train-1472.scene_instance.json", + "./3/ProcTHOR-Train-1938.scene_instance.json", + "./3/ProcTHOR-Train-1975.scene_instance.json", + "./3/ProcTHOR-Train-1260.scene_instance.json", + "./3/ProcTHOR-Train-1455.scene_instance.json", + "./3/ProcTHOR-Train-1721.scene_instance.json", + "./3/ProcTHOR-Train-1290.scene_instance.json", + "./3/ProcTHOR-Train-1025.scene_instance.json", + "./3/ProcTHOR-Train-1554.scene_instance.json", + "./3/ProcTHOR-Train-1552.scene_instance.json", + "./3/ProcTHOR-Train-1840.scene_instance.json", + "./3/ProcTHOR-Train-1571.scene_instance.json", + "./3/ProcTHOR-Train-1466.scene_instance.json", + "./3/ProcTHOR-Train-1047.scene_instance.json", + "./3/ProcTHOR-Train-1077.scene_instance.json", + "./3/ProcTHOR-Train-1880.scene_instance.json", + "./3/ProcTHOR-Train-1828.scene_instance.json", + "./3/ProcTHOR-Train-1315.scene_instance.json", + "./3/ProcTHOR-Train-1924.scene_instance.json", + "./3/ProcTHOR-Train-1556.scene_instance.json", + "./3/ProcTHOR-Train-1111.scene_instance.json", + "./3/ProcTHOR-Train-1510.scene_instance.json", + "./3/ProcTHOR-Train-1916.scene_instance.json", + "./3/ProcTHOR-Train-1295.scene_instance.json", + "./3/ProcTHOR-Train-1705.scene_instance.json", + "./3/ProcTHOR-Train-1437.scene_instance.json", + "./3/ProcTHOR-Train-1695.scene_instance.json", + "./3/ProcTHOR-Train-1149.scene_instance.json", + "./3/ProcTHOR-Train-1439.scene_instance.json", + "./3/ProcTHOR-Train-1473.scene_instance.json", + "./3/ProcTHOR-Train-1993.scene_instance.json", + "./3/ProcTHOR-Train-1889.scene_instance.json", + "./3/ProcTHOR-Train-1711.scene_instance.json", + "./3/ProcTHOR-Train-1587.scene_instance.json", + "./3/ProcTHOR-Train-1796.scene_instance.json", + "./3/ProcTHOR-Train-1004.scene_instance.json", + "./3/ProcTHOR-Train-1631.scene_instance.json", + "./3/ProcTHOR-Train-1480.scene_instance.json", + "./3/ProcTHOR-Train-1752.scene_instance.json", + "./3/ProcTHOR-Train-1373.scene_instance.json", + "./3/ProcTHOR-Train-1067.scene_instance.json", + "./3/ProcTHOR-Train-1835.scene_instance.json", + "./3/ProcTHOR-Train-1250.scene_instance.json", + "./3/ProcTHOR-Train-1355.scene_instance.json", + "./3/ProcTHOR-Train-1477.scene_instance.json", + "./3/ProcTHOR-Train-1904.scene_instance.json", + "./3/ProcTHOR-Train-1209.scene_instance.json", + "./3/ProcTHOR-Train-1415.scene_instance.json", + "./3/ProcTHOR-Train-1332.scene_instance.json", + "./3/ProcTHOR-Train-1319.scene_instance.json", + "./3/ProcTHOR-Train-1229.scene_instance.json", + "./3/ProcTHOR-Train-1048.scene_instance.json", + "./3/ProcTHOR-Train-1272.scene_instance.json", + "./3/ProcTHOR-Train-1743.scene_instance.json", + "./3/ProcTHOR-Train-1126.scene_instance.json", + "./3/ProcTHOR-Train-1329.scene_instance.json", + "./3/ProcTHOR-Train-1079.scene_instance.json", + "./3/ProcTHOR-Train-1270.scene_instance.json", + "./3/ProcTHOR-Train-1046.scene_instance.json", + "./3/ProcTHOR-Train-1010.scene_instance.json", + "./3/ProcTHOR-Train-1246.scene_instance.json", + "./3/ProcTHOR-Train-1115.scene_instance.json", + "./3/ProcTHOR-Train-1481.scene_instance.json", + "./3/ProcTHOR-Train-1089.scene_instance.json", + "./3/ProcTHOR-Train-1091.scene_instance.json", + "./3/ProcTHOR-Train-1505.scene_instance.json", + "./3/ProcTHOR-Train-1696.scene_instance.json", + "./3/ProcTHOR-Train-1255.scene_instance.json", + "./3/ProcTHOR-Train-1808.scene_instance.json", + "./3/ProcTHOR-Train-1146.scene_instance.json", + "./3/ProcTHOR-Train-1251.scene_instance.json", + "./3/ProcTHOR-Train-1848.scene_instance.json", + "./3/ProcTHOR-Train-1870.scene_instance.json", + "./3/ProcTHOR-Train-1886.scene_instance.json", + "./3/ProcTHOR-Train-1987.scene_instance.json", + "./3/ProcTHOR-Train-1940.scene_instance.json", + "./3/ProcTHOR-Train-1032.scene_instance.json", + "./3/ProcTHOR-Train-1882.scene_instance.json", + "./3/ProcTHOR-Train-1168.scene_instance.json", + "./3/ProcTHOR-Train-1392.scene_instance.json", + "./3/ProcTHOR-Train-1825.scene_instance.json", + "./3/ProcTHOR-Train-1626.scene_instance.json", + "./3/ProcTHOR-Train-1761.scene_instance.json", + "./3/ProcTHOR-Train-1459.scene_instance.json", + "./3/ProcTHOR-Train-1396.scene_instance.json", + "./3/ProcTHOR-Train-1740.scene_instance.json", + "./3/ProcTHOR-Train-1590.scene_instance.json", + "./3/ProcTHOR-Train-1063.scene_instance.json", + "./3/ProcTHOR-Train-1597.scene_instance.json", + "./3/ProcTHOR-Train-1132.scene_instance.json", + "./3/ProcTHOR-Train-1816.scene_instance.json", + "./3/ProcTHOR-Train-1876.scene_instance.json", + "./3/ProcTHOR-Train-1518.scene_instance.json", + "./3/ProcTHOR-Train-1362.scene_instance.json", + "./3/ProcTHOR-Train-1214.scene_instance.json", + "./3/ProcTHOR-Train-1411.scene_instance.json", + "./3/ProcTHOR-Train-1401.scene_instance.json", + "./3/ProcTHOR-Train-1434.scene_instance.json", + "./3/ProcTHOR-Train-1169.scene_instance.json", + "./3/ProcTHOR-Train-1578.scene_instance.json", + "./3/ProcTHOR-Train-1488.scene_instance.json", + "./3/ProcTHOR-Train-1986.scene_instance.json", + "./3/ProcTHOR-Train-1791.scene_instance.json", + "./3/ProcTHOR-Train-1386.scene_instance.json", + "./3/ProcTHOR-Train-1712.scene_instance.json", + "./3/ProcTHOR-Train-1523.scene_instance.json", + "./3/ProcTHOR-Train-1584.scene_instance.json", + "./3/ProcTHOR-Train-1754.scene_instance.json", + "./3/ProcTHOR-Train-1506.scene_instance.json", + "./3/ProcTHOR-Train-1530.scene_instance.json", + "./3/ProcTHOR-Train-1676.scene_instance.json", + "./3/ProcTHOR-Train-1093.scene_instance.json", + "./3/ProcTHOR-Train-1967.scene_instance.json", + "./3/ProcTHOR-Train-1639.scene_instance.json", + "./3/ProcTHOR-Train-1133.scene_instance.json", + "./3/ProcTHOR-Train-1723.scene_instance.json", + "./3/ProcTHOR-Train-1841.scene_instance.json", + "./3/ProcTHOR-Train-1128.scene_instance.json", + "./3/ProcTHOR-Train-1402.scene_instance.json", + "./3/ProcTHOR-Train-1600.scene_instance.json", + "./3/ProcTHOR-Train-1433.scene_instance.json", + "./3/ProcTHOR-Train-1259.scene_instance.json", + "./3/ProcTHOR-Train-1524.scene_instance.json", + "./3/ProcTHOR-Train-1387.scene_instance.json", + "./3/ProcTHOR-Train-1019.scene_instance.json", + "./3/ProcTHOR-Train-1580.scene_instance.json", + "./3/ProcTHOR-Train-1635.scene_instance.json", + "./3/ProcTHOR-Train-1071.scene_instance.json", + "./3/ProcTHOR-Train-1548.scene_instance.json", + "./3/ProcTHOR-Train-1912.scene_instance.json", + "./3/ProcTHOR-Train-1900.scene_instance.json", + "./3/ProcTHOR-Train-1601.scene_instance.json", + "./3/ProcTHOR-Train-1576.scene_instance.json", + "./3/ProcTHOR-Train-1242.scene_instance.json", + "./3/ProcTHOR-Train-1239.scene_instance.json", + "./3/ProcTHOR-Train-1857.scene_instance.json", + "./3/ProcTHOR-Train-1953.scene_instance.json", + "./3/ProcTHOR-Train-1942.scene_instance.json", + "./3/ProcTHOR-Train-1663.scene_instance.json", + "./3/ProcTHOR-Train-1103.scene_instance.json", + "./3/ProcTHOR-Train-1643.scene_instance.json", + "./3/ProcTHOR-Train-1243.scene_instance.json", + "./3/ProcTHOR-Train-1998.scene_instance.json", + "./3/ProcTHOR-Train-1342.scene_instance.json", + "./3/ProcTHOR-Train-1674.scene_instance.json", + "./3/ProcTHOR-Train-1786.scene_instance.json", + "./3/ProcTHOR-Train-1291.scene_instance.json", + "./3/ProcTHOR-Train-1368.scene_instance.json", + "./3/ProcTHOR-Train-1644.scene_instance.json", + "./3/ProcTHOR-Train-1812.scene_instance.json", + "./3/ProcTHOR-Train-1062.scene_instance.json", + "./3/ProcTHOR-Train-1398.scene_instance.json", + "./3/ProcTHOR-Train-1817.scene_instance.json", + "./3/ProcTHOR-Train-1909.scene_instance.json", + "./3/ProcTHOR-Train-1884.scene_instance.json", + "./3/ProcTHOR-Train-1606.scene_instance.json", + "./3/ProcTHOR-Train-1834.scene_instance.json", + "./3/ProcTHOR-Train-1371.scene_instance.json", + "./3/ProcTHOR-Train-1470.scene_instance.json", + "./3/ProcTHOR-Train-1861.scene_instance.json", + "./3/ProcTHOR-Train-1680.scene_instance.json", + "./3/ProcTHOR-Train-1285.scene_instance.json", + "./3/ProcTHOR-Train-1533.scene_instance.json", + "./3/ProcTHOR-Train-1878.scene_instance.json", + "./3/ProcTHOR-Train-1555.scene_instance.json", + "./3/ProcTHOR-Train-1116.scene_instance.json", + "./3/ProcTHOR-Train-1150.scene_instance.json", + "./3/ProcTHOR-Train-1138.scene_instance.json", + "./3/ProcTHOR-Train-1572.scene_instance.json", + "./3/ProcTHOR-Train-1184.scene_instance.json", + "./3/ProcTHOR-Train-1589.scene_instance.json", + "./3/ProcTHOR-Train-1605.scene_instance.json", + "./3/ProcTHOR-Train-1628.scene_instance.json", + "./3/ProcTHOR-Train-1337.scene_instance.json", + "./3/ProcTHOR-Train-1226.scene_instance.json", + "./3/ProcTHOR-Train-1919.scene_instance.json", + "./3/ProcTHOR-Train-1720.scene_instance.json", + "./3/ProcTHOR-Train-1221.scene_instance.json", + "./3/ProcTHOR-Train-1235.scene_instance.json", + "./3/ProcTHOR-Train-1815.scene_instance.json", + "./3/ProcTHOR-Train-1428.scene_instance.json", + "./3/ProcTHOR-Train-1640.scene_instance.json", + "./3/ProcTHOR-Train-1822.scene_instance.json", + "./3/ProcTHOR-Train-1007.scene_instance.json", + "./3/ProcTHOR-Train-1153.scene_instance.json", + "./3/ProcTHOR-Train-1302.scene_instance.json", + "./3/ProcTHOR-Train-1464.scene_instance.json", + "./3/ProcTHOR-Train-1360.scene_instance.json", + "./3/ProcTHOR-Train-1885.scene_instance.json", + "./3/ProcTHOR-Train-1357.scene_instance.json", + "./3/ProcTHOR-Train-1086.scene_instance.json", + "./3/ProcTHOR-Train-1450.scene_instance.json", + "./3/ProcTHOR-Train-1033.scene_instance.json", + "./3/ProcTHOR-Train-1866.scene_instance.json", + "./3/ProcTHOR-Train-1384.scene_instance.json", + "./3/ProcTHOR-Train-1917.scene_instance.json", + "./3/ProcTHOR-Train-1811.scene_instance.json", + "./3/ProcTHOR-Train-1689.scene_instance.json", + "./3/ProcTHOR-Train-1322.scene_instance.json", + "./3/ProcTHOR-Train-1102.scene_instance.json", + "./3/ProcTHOR-Train-1162.scene_instance.json", + "./3/ProcTHOR-Train-1304.scene_instance.json", + "./3/ProcTHOR-Train-1991.scene_instance.json", + "./3/ProcTHOR-Train-1838.scene_instance.json", + "./3/ProcTHOR-Train-1950.scene_instance.json", + "./3/ProcTHOR-Train-1353.scene_instance.json", + "./3/ProcTHOR-Train-1911.scene_instance.json", + "./3/ProcTHOR-Train-1988.scene_instance.json", + "./3/ProcTHOR-Train-1502.scene_instance.json", + "./3/ProcTHOR-Train-1508.scene_instance.json", + "./3/ProcTHOR-Train-1476.scene_instance.json", + "./3/ProcTHOR-Train-1681.scene_instance.json", + "./3/ProcTHOR-Train-1593.scene_instance.json", + "./3/ProcTHOR-Train-1467.scene_instance.json", + "./3/ProcTHOR-Train-1008.scene_instance.json", + "./3/ProcTHOR-Train-1172.scene_instance.json", + "./3/ProcTHOR-Train-1759.scene_instance.json", + "./3/ProcTHOR-Train-1952.scene_instance.json", + "./3/ProcTHOR-Train-1700.scene_instance.json", + "./3/ProcTHOR-Train-1487.scene_instance.json", + "./3/ProcTHOR-Train-1875.scene_instance.json", + "./3/ProcTHOR-Train-1369.scene_instance.json", + "./3/ProcTHOR-Train-1574.scene_instance.json", + "./3/ProcTHOR-Train-1774.scene_instance.json", + "./3/ProcTHOR-Train-1666.scene_instance.json", + "./3/ProcTHOR-Train-1702.scene_instance.json", + "./3/ProcTHOR-Train-1787.scene_instance.json", + "./3/ProcTHOR-Train-1725.scene_instance.json", + "./3/ProcTHOR-Train-1310.scene_instance.json", + "./3/ProcTHOR-Train-1241.scene_instance.json", + "./3/ProcTHOR-Train-1570.scene_instance.json", + "./3/ProcTHOR-Train-1127.scene_instance.json", + "./3/ProcTHOR-Train-1544.scene_instance.json", + "./3/ProcTHOR-Train-1929.scene_instance.json", + "./3/ProcTHOR-Train-1328.scene_instance.json", + "./3/ProcTHOR-Train-1654.scene_instance.json", + "./3/ProcTHOR-Train-1794.scene_instance.json", + "./3/ProcTHOR-Train-1660.scene_instance.json", + "./3/ProcTHOR-Train-1726.scene_instance.json", + "./3/ProcTHOR-Train-1611.scene_instance.json", + "./3/ProcTHOR-Train-1773.scene_instance.json", + "./3/ProcTHOR-Train-1526.scene_instance.json", + "./3/ProcTHOR-Train-1028.scene_instance.json", + "./3/ProcTHOR-Train-1165.scene_instance.json", + "./3/ProcTHOR-Train-1262.scene_instance.json", + "./3/ProcTHOR-Train-1163.scene_instance.json", + "./3/ProcTHOR-Train-1819.scene_instance.json", + "./3/ProcTHOR-Train-1956.scene_instance.json", + "./3/ProcTHOR-Train-1836.scene_instance.json", + "./3/ProcTHOR-Train-1174.scene_instance.json", + "./3/ProcTHOR-Train-1375.scene_instance.json", + "./3/ProcTHOR-Train-1667.scene_instance.json", + "./3/ProcTHOR-Train-1023.scene_instance.json", + "./3/ProcTHOR-Train-1407.scene_instance.json", + "./3/ProcTHOR-Train-1749.scene_instance.json", + "./3/ProcTHOR-Train-1910.scene_instance.json", + "./3/ProcTHOR-Train-1610.scene_instance.json", + "./3/ProcTHOR-Train-1763.scene_instance.json", + "./3/ProcTHOR-Train-1719.scene_instance.json", + "./3/ProcTHOR-Train-1577.scene_instance.json", + "./3/ProcTHOR-Train-1744.scene_instance.json", + "./3/ProcTHOR-Train-1553.scene_instance.json", + "./3/ProcTHOR-Train-1732.scene_instance.json", + "./3/ProcTHOR-Train-1486.scene_instance.json", + "./3/ProcTHOR-Train-1655.scene_instance.json", + "./3/ProcTHOR-Train-1604.scene_instance.json", + "./3/ProcTHOR-Train-1534.scene_instance.json", + "./3/ProcTHOR-Train-1760.scene_instance.json", + "./3/ProcTHOR-Train-1658.scene_instance.json", + "./3/ProcTHOR-Train-1320.scene_instance.json", + "./3/ProcTHOR-Train-1289.scene_instance.json", + "./3/ProcTHOR-Train-1490.scene_instance.json", + "./3/ProcTHOR-Train-1561.scene_instance.json", + "./3/ProcTHOR-Train-1893.scene_instance.json", + "./3/ProcTHOR-Train-1152.scene_instance.json", + "./3/ProcTHOR-Train-1746.scene_instance.json", + "./3/ProcTHOR-Train-1771.scene_instance.json", + "./3/ProcTHOR-Train-1810.scene_instance.json", + "./3/ProcTHOR-Train-1961.scene_instance.json", + "./3/ProcTHOR-Train-1189.scene_instance.json", + "./3/ProcTHOR-Train-1247.scene_instance.json", + "./3/ProcTHOR-Train-1140.scene_instance.json", + "./3/ProcTHOR-Train-1565.scene_instance.json", + "./3/ProcTHOR-Train-1284.scene_instance.json", + "./3/ProcTHOR-Train-1022.scene_instance.json", + "./3/ProcTHOR-Train-1050.scene_instance.json", + "./3/ProcTHOR-Train-1223.scene_instance.json", + "./3/ProcTHOR-Train-1996.scene_instance.json", + "./3/ProcTHOR-Train-1649.scene_instance.json", + "./3/ProcTHOR-Train-1408.scene_instance.json", + "./3/ProcTHOR-Train-1175.scene_instance.json", + "./3/ProcTHOR-Train-1107.scene_instance.json", + "./3/ProcTHOR-Train-1651.scene_instance.json", + "./3/ProcTHOR-Train-1955.scene_instance.json", + "./3/ProcTHOR-Train-1514.scene_instance.json", + "./3/ProcTHOR-Train-1567.scene_instance.json", + "./3/ProcTHOR-Train-1176.scene_instance.json", + "./3/ProcTHOR-Train-1837.scene_instance.json", + "./3/ProcTHOR-Train-1096.scene_instance.json", + "./3/ProcTHOR-Train-1821.scene_instance.json", + "./3/ProcTHOR-Train-1413.scene_instance.json", + "./3/ProcTHOR-Train-1977.scene_instance.json", + "./3/ProcTHOR-Train-1494.scene_instance.json", + "./3/ProcTHOR-Train-1104.scene_instance.json", + "./3/ProcTHOR-Train-1208.scene_instance.json", + "./3/ProcTHOR-Train-1888.scene_instance.json", + "./3/ProcTHOR-Train-1298.scene_instance.json", + "./3/ProcTHOR-Train-1118.scene_instance.json", + "./3/ProcTHOR-Train-1122.scene_instance.json", + "./3/ProcTHOR-Train-1341.scene_instance.json", + "./3/ProcTHOR-Train-1856.scene_instance.json", + "./3/ProcTHOR-Train-1670.scene_instance.json", + "./3/ProcTHOR-Train-1781.scene_instance.json", + "./3/ProcTHOR-Train-1442.scene_instance.json", + "./3/ProcTHOR-Train-1932.scene_instance.json", + "./3/ProcTHOR-Train-1638.scene_instance.json", + "./3/ProcTHOR-Train-1217.scene_instance.json", + "./3/ProcTHOR-Train-1729.scene_instance.json", + "./3/ProcTHOR-Train-1299.scene_instance.json", + "./3/ProcTHOR-Train-1541.scene_instance.json", + "./3/ProcTHOR-Train-1313.scene_instance.json", + "./3/ProcTHOR-Train-1449.scene_instance.json", + "./3/ProcTHOR-Train-1668.scene_instance.json", + "./3/ProcTHOR-Train-1378.scene_instance.json", + "./3/ProcTHOR-Train-1976.scene_instance.json", + "./3/ProcTHOR-Train-1029.scene_instance.json", + "./3/ProcTHOR-Train-1751.scene_instance.json", + "./3/ProcTHOR-Train-1536.scene_instance.json", + "./3/ProcTHOR-Train-1346.scene_instance.json", + "./3/ProcTHOR-Train-1424.scene_instance.json", + "./3/ProcTHOR-Train-1002.scene_instance.json", + "./3/ProcTHOR-Train-1735.scene_instance.json", + "./3/ProcTHOR-Train-1918.scene_instance.json", + "./3/ProcTHOR-Train-1868.scene_instance.json", + "./3/ProcTHOR-Train-1914.scene_instance.json", + "./3/ProcTHOR-Train-1159.scene_instance.json", + "./3/ProcTHOR-Train-1206.scene_instance.json", + "./3/ProcTHOR-Train-1234.scene_instance.json", + "./3/ProcTHOR-Train-1994.scene_instance.json", + "./3/ProcTHOR-Train-1463.scene_instance.json", + "./3/ProcTHOR-Train-1207.scene_instance.json", + "./3/ProcTHOR-Train-1018.scene_instance.json", + "./3/ProcTHOR-Train-1776.scene_instance.json", + "./3/ProcTHOR-Train-1296.scene_instance.json", + "./3/ProcTHOR-Train-1661.scene_instance.json", + "./3/ProcTHOR-Train-1021.scene_instance.json", + "./3/ProcTHOR-Train-1622.scene_instance.json", + "./3/ProcTHOR-Train-1646.scene_instance.json", + "./3/ProcTHOR-Train-1964.scene_instance.json", + "./3/ProcTHOR-Train-1906.scene_instance.json", + "./3/ProcTHOR-Train-1300.scene_instance.json", + "./3/ProcTHOR-Train-1364.scene_instance.json", + "./3/ProcTHOR-Train-1072.scene_instance.json", + "./3/ProcTHOR-Train-1314.scene_instance.json", + "./3/ProcTHOR-Train-1051.scene_instance.json", + "./3/ProcTHOR-Train-1412.scene_instance.json", + "./3/ProcTHOR-Train-1160.scene_instance.json", + "./3/ProcTHOR-Train-1327.scene_instance.json", + "./3/ProcTHOR-Train-1323.scene_instance.json", + "./3/ProcTHOR-Train-1947.scene_instance.json", + "./3/ProcTHOR-Train-1012.scene_instance.json", + "./3/ProcTHOR-Train-1181.scene_instance.json", + "./3/ProcTHOR-Train-1421.scene_instance.json", + "./3/ProcTHOR-Train-1881.scene_instance.json", + "./3/ProcTHOR-Train-1399.scene_instance.json", + "./3/ProcTHOR-Train-1245.scene_instance.json", + "./3/ProcTHOR-Train-1045.scene_instance.json", + "./3/ProcTHOR-Train-1690.scene_instance.json", + "./3/ProcTHOR-Train-1832.scene_instance.json", + "./3/ProcTHOR-Train-1297.scene_instance.json", + "./3/ProcTHOR-Train-1143.scene_instance.json", + "./3/ProcTHOR-Train-1190.scene_instance.json", + "./3/ProcTHOR-Train-1782.scene_instance.json", + "./3/ProcTHOR-Train-1167.scene_instance.json", + "./3/ProcTHOR-Train-1758.scene_instance.json", + "./3/ProcTHOR-Train-1282.scene_instance.json", + "./3/ProcTHOR-Train-1766.scene_instance.json", + "./3/ProcTHOR-Train-1325.scene_instance.json", + "./3/ProcTHOR-Train-1826.scene_instance.json", + "./3/ProcTHOR-Train-1382.scene_instance.json", + "./3/ProcTHOR-Train-1447.scene_instance.json", + "./3/ProcTHOR-Train-1846.scene_instance.json", + "./3/ProcTHOR-Train-1055.scene_instance.json", + "./3/ProcTHOR-Train-1633.scene_instance.json", + "./3/ProcTHOR-Train-1535.scene_instance.json", + "./3/ProcTHOR-Train-1192.scene_instance.json", + "./3/ProcTHOR-Train-1727.scene_instance.json", + "./3/ProcTHOR-Train-1915.scene_instance.json", + "./3/ProcTHOR-Train-1389.scene_instance.json", + "./3/ProcTHOR-Train-1879.scene_instance.json", + "./3/ProcTHOR-Train-1197.scene_instance.json", + "./3/ProcTHOR-Train-1546.scene_instance.json", + "./3/ProcTHOR-Train-1873.scene_instance.json", + "./3/ProcTHOR-Train-1131.scene_instance.json", + "./3/ProcTHOR-Train-1137.scene_instance.json", + "./3/ProcTHOR-Train-1874.scene_instance.json", + "./3/ProcTHOR-Train-1790.scene_instance.json", + "./3/ProcTHOR-Train-1803.scene_instance.json", + "./3/ProcTHOR-Train-1498.scene_instance.json", + "./3/ProcTHOR-Train-1187.scene_instance.json", + "./3/ProcTHOR-Train-1507.scene_instance.json", + "./3/ProcTHOR-Train-1697.scene_instance.json", + "./3/ProcTHOR-Train-1583.scene_instance.json", + "./3/ProcTHOR-Train-1564.scene_instance.json", + "./3/ProcTHOR-Train-1155.scene_instance.json", + "./3/ProcTHOR-Train-1973.scene_instance.json", + "./3/ProcTHOR-Train-1807.scene_instance.json", + "./7/ProcTHOR-Train-5318.scene_instance.json", + "./7/ProcTHOR-Train-5558.scene_instance.json", + "./7/ProcTHOR-Train-5864.scene_instance.json", + "./7/ProcTHOR-Train-5846.scene_instance.json", + "./7/ProcTHOR-Train-5198.scene_instance.json", + "./7/ProcTHOR-Train-5266.scene_instance.json", + "./7/ProcTHOR-Train-5669.scene_instance.json", + "./7/ProcTHOR-Train-5919.scene_instance.json", + "./7/ProcTHOR-Train-5171.scene_instance.json", + "./7/ProcTHOR-Train-5506.scene_instance.json", + "./7/ProcTHOR-Train-5667.scene_instance.json", + "./7/ProcTHOR-Train-5166.scene_instance.json", + "./7/ProcTHOR-Train-5413.scene_instance.json", + "./7/ProcTHOR-Train-5815.scene_instance.json", + "./7/ProcTHOR-Train-5181.scene_instance.json", + "./7/ProcTHOR-Train-5800.scene_instance.json", + "./7/ProcTHOR-Train-5399.scene_instance.json", + "./7/ProcTHOR-Train-5020.scene_instance.json", + "./7/ProcTHOR-Train-5083.scene_instance.json", + "./7/ProcTHOR-Train-5699.scene_instance.json", + "./7/ProcTHOR-Train-5859.scene_instance.json", + "./7/ProcTHOR-Train-5488.scene_instance.json", + "./7/ProcTHOR-Train-5255.scene_instance.json", + "./7/ProcTHOR-Train-5587.scene_instance.json", + "./7/ProcTHOR-Train-5759.scene_instance.json", + "./7/ProcTHOR-Train-5988.scene_instance.json", + "./7/ProcTHOR-Train-5303.scene_instance.json", + "./7/ProcTHOR-Train-5044.scene_instance.json", + "./7/ProcTHOR-Train-5203.scene_instance.json", + "./7/ProcTHOR-Train-5346.scene_instance.json", + "./7/ProcTHOR-Train-5210.scene_instance.json", + "./7/ProcTHOR-Train-5446.scene_instance.json", + "./7/ProcTHOR-Train-5097.scene_instance.json", + "./7/ProcTHOR-Train-5654.scene_instance.json", + "./7/ProcTHOR-Train-5977.scene_instance.json", + "./7/ProcTHOR-Train-5931.scene_instance.json", + "./7/ProcTHOR-Train-5177.scene_instance.json", + "./7/ProcTHOR-Train-5366.scene_instance.json", + "./7/ProcTHOR-Train-5511.scene_instance.json", + "./7/ProcTHOR-Train-5666.scene_instance.json", + "./7/ProcTHOR-Train-5404.scene_instance.json", + "./7/ProcTHOR-Train-5125.scene_instance.json", + "./7/ProcTHOR-Train-5705.scene_instance.json", + "./7/ProcTHOR-Train-5680.scene_instance.json", + "./7/ProcTHOR-Train-5688.scene_instance.json", + "./7/ProcTHOR-Train-5626.scene_instance.json", + "./7/ProcTHOR-Train-5021.scene_instance.json", + "./7/ProcTHOR-Train-5401.scene_instance.json", + "./7/ProcTHOR-Train-5338.scene_instance.json", + "./7/ProcTHOR-Train-5373.scene_instance.json", + "./7/ProcTHOR-Train-5337.scene_instance.json", + "./7/ProcTHOR-Train-5732.scene_instance.json", + "./7/ProcTHOR-Train-5249.scene_instance.json", + "./7/ProcTHOR-Train-5064.scene_instance.json", + "./7/ProcTHOR-Train-5302.scene_instance.json", + "./7/ProcTHOR-Train-5831.scene_instance.json", + "./7/ProcTHOR-Train-5334.scene_instance.json", + "./7/ProcTHOR-Train-5632.scene_instance.json", + "./7/ProcTHOR-Train-5191.scene_instance.json", + "./7/ProcTHOR-Train-5726.scene_instance.json", + "./7/ProcTHOR-Train-5258.scene_instance.json", + "./7/ProcTHOR-Train-5323.scene_instance.json", + "./7/ProcTHOR-Train-5117.scene_instance.json", + "./7/ProcTHOR-Train-5048.scene_instance.json", + "./7/ProcTHOR-Train-5447.scene_instance.json", + "./7/ProcTHOR-Train-5796.scene_instance.json", + "./7/ProcTHOR-Train-5096.scene_instance.json", + "./7/ProcTHOR-Train-5745.scene_instance.json", + "./7/ProcTHOR-Train-5202.scene_instance.json", + "./7/ProcTHOR-Train-5914.scene_instance.json", + "./7/ProcTHOR-Train-5712.scene_instance.json", + "./7/ProcTHOR-Train-5989.scene_instance.json", + "./7/ProcTHOR-Train-5956.scene_instance.json", + "./7/ProcTHOR-Train-5715.scene_instance.json", + "./7/ProcTHOR-Train-5865.scene_instance.json", + "./7/ProcTHOR-Train-5130.scene_instance.json", + "./7/ProcTHOR-Train-5328.scene_instance.json", + "./7/ProcTHOR-Train-5813.scene_instance.json", + "./7/ProcTHOR-Train-5906.scene_instance.json", + "./7/ProcTHOR-Train-5880.scene_instance.json", + "./7/ProcTHOR-Train-5735.scene_instance.json", + "./7/ProcTHOR-Train-5548.scene_instance.json", + "./7/ProcTHOR-Train-5946.scene_instance.json", + "./7/ProcTHOR-Train-5933.scene_instance.json", + "./7/ProcTHOR-Train-5425.scene_instance.json", + "./7/ProcTHOR-Train-5655.scene_instance.json", + "./7/ProcTHOR-Train-5276.scene_instance.json", + "./7/ProcTHOR-Train-5152.scene_instance.json", + "./7/ProcTHOR-Train-5187.scene_instance.json", + "./7/ProcTHOR-Train-5351.scene_instance.json", + "./7/ProcTHOR-Train-5103.scene_instance.json", + "./7/ProcTHOR-Train-5017.scene_instance.json", + "./7/ProcTHOR-Train-5658.scene_instance.json", + "./7/ProcTHOR-Train-5161.scene_instance.json", + "./7/ProcTHOR-Train-5647.scene_instance.json", + "./7/ProcTHOR-Train-5426.scene_instance.json", + "./7/ProcTHOR-Train-5585.scene_instance.json", + "./7/ProcTHOR-Train-5879.scene_instance.json", + "./7/ProcTHOR-Train-5937.scene_instance.json", + "./7/ProcTHOR-Train-5487.scene_instance.json", + "./7/ProcTHOR-Train-5638.scene_instance.json", + "./7/ProcTHOR-Train-5220.scene_instance.json", + "./7/ProcTHOR-Train-5069.scene_instance.json", + "./7/ProcTHOR-Train-5678.scene_instance.json", + "./7/ProcTHOR-Train-5458.scene_instance.json", + "./7/ProcTHOR-Train-5619.scene_instance.json", + "./7/ProcTHOR-Train-5871.scene_instance.json", + "./7/ProcTHOR-Train-5089.scene_instance.json", + "./7/ProcTHOR-Train-5747.scene_instance.json", + "./7/ProcTHOR-Train-5741.scene_instance.json", + "./7/ProcTHOR-Train-5886.scene_instance.json", + "./7/ProcTHOR-Train-5250.scene_instance.json", + "./7/ProcTHOR-Train-5930.scene_instance.json", + "./7/ProcTHOR-Train-5971.scene_instance.json", + "./7/ProcTHOR-Train-5444.scene_instance.json", + "./7/ProcTHOR-Train-5718.scene_instance.json", + "./7/ProcTHOR-Train-5106.scene_instance.json", + "./7/ProcTHOR-Train-5679.scene_instance.json", + "./7/ProcTHOR-Train-5772.scene_instance.json", + "./7/ProcTHOR-Train-5640.scene_instance.json", + "./7/ProcTHOR-Train-5986.scene_instance.json", + "./7/ProcTHOR-Train-5417.scene_instance.json", + "./7/ProcTHOR-Train-5497.scene_instance.json", + "./7/ProcTHOR-Train-5692.scene_instance.json", + "./7/ProcTHOR-Train-5565.scene_instance.json", + "./7/ProcTHOR-Train-5199.scene_instance.json", + "./7/ProcTHOR-Train-5062.scene_instance.json", + "./7/ProcTHOR-Train-5904.scene_instance.json", + "./7/ProcTHOR-Train-5281.scene_instance.json", + "./7/ProcTHOR-Train-5325.scene_instance.json", + "./7/ProcTHOR-Train-5648.scene_instance.json", + "./7/ProcTHOR-Train-5295.scene_instance.json", + "./7/ProcTHOR-Train-5016.scene_instance.json", + "./7/ProcTHOR-Train-5429.scene_instance.json", + "./7/ProcTHOR-Train-5070.scene_instance.json", + "./7/ProcTHOR-Train-5520.scene_instance.json", + "./7/ProcTHOR-Train-5226.scene_instance.json", + "./7/ProcTHOR-Train-5362.scene_instance.json", + "./7/ProcTHOR-Train-5590.scene_instance.json", + "./7/ProcTHOR-Train-5858.scene_instance.json", + "./7/ProcTHOR-Train-5134.scene_instance.json", + "./7/ProcTHOR-Train-5521.scene_instance.json", + "./7/ProcTHOR-Train-5958.scene_instance.json", + "./7/ProcTHOR-Train-5940.scene_instance.json", + "./7/ProcTHOR-Train-5167.scene_instance.json", + "./7/ProcTHOR-Train-5235.scene_instance.json", + "./7/ProcTHOR-Train-5749.scene_instance.json", + "./7/ProcTHOR-Train-5758.scene_instance.json", + "./7/ProcTHOR-Train-5850.scene_instance.json", + "./7/ProcTHOR-Train-5744.scene_instance.json", + "./7/ProcTHOR-Train-5370.scene_instance.json", + "./7/ProcTHOR-Train-5729.scene_instance.json", + "./7/ProcTHOR-Train-5200.scene_instance.json", + "./7/ProcTHOR-Train-5571.scene_instance.json", + "./7/ProcTHOR-Train-5923.scene_instance.json", + "./7/ProcTHOR-Train-5076.scene_instance.json", + "./7/ProcTHOR-Train-5610.scene_instance.json", + "./7/ProcTHOR-Train-5560.scene_instance.json", + "./7/ProcTHOR-Train-5267.scene_instance.json", + "./7/ProcTHOR-Train-5279.scene_instance.json", + "./7/ProcTHOR-Train-5051.scene_instance.json", + "./7/ProcTHOR-Train-5941.scene_instance.json", + "./7/ProcTHOR-Train-5985.scene_instance.json", + "./7/ProcTHOR-Train-5336.scene_instance.json", + "./7/ProcTHOR-Train-5356.scene_instance.json", + "./7/ProcTHOR-Train-5855.scene_instance.json", + "./7/ProcTHOR-Train-5071.scene_instance.json", + "./7/ProcTHOR-Train-5056.scene_instance.json", + "./7/ProcTHOR-Train-5068.scene_instance.json", + "./7/ProcTHOR-Train-5556.scene_instance.json", + "./7/ProcTHOR-Train-5381.scene_instance.json", + "./7/ProcTHOR-Train-5449.scene_instance.json", + "./7/ProcTHOR-Train-5810.scene_instance.json", + "./7/ProcTHOR-Train-5031.scene_instance.json", + "./7/ProcTHOR-Train-5581.scene_instance.json", + "./7/ProcTHOR-Train-5686.scene_instance.json", + "./7/ProcTHOR-Train-5788.scene_instance.json", + "./7/ProcTHOR-Train-5025.scene_instance.json", + "./7/ProcTHOR-Train-5999.scene_instance.json", + "./7/ProcTHOR-Train-5537.scene_instance.json", + "./7/ProcTHOR-Train-5662.scene_instance.json", + "./7/ProcTHOR-Train-5000.scene_instance.json", + "./7/ProcTHOR-Train-5779.scene_instance.json", + "./7/ProcTHOR-Train-5860.scene_instance.json", + "./7/ProcTHOR-Train-5122.scene_instance.json", + "./7/ProcTHOR-Train-5352.scene_instance.json", + "./7/ProcTHOR-Train-5361.scene_instance.json", + "./7/ProcTHOR-Train-5146.scene_instance.json", + "./7/ProcTHOR-Train-5013.scene_instance.json", + "./7/ProcTHOR-Train-5905.scene_instance.json", + "./7/ProcTHOR-Train-5996.scene_instance.json", + "./7/ProcTHOR-Train-5913.scene_instance.json", + "./7/ProcTHOR-Train-5530.scene_instance.json", + "./7/ProcTHOR-Train-5935.scene_instance.json", + "./7/ProcTHOR-Train-5921.scene_instance.json", + "./7/ProcTHOR-Train-5685.scene_instance.json", + "./7/ProcTHOR-Train-5561.scene_instance.json", + "./7/ProcTHOR-Train-5891.scene_instance.json", + "./7/ProcTHOR-Train-5192.scene_instance.json", + "./7/ProcTHOR-Train-5047.scene_instance.json", + "./7/ProcTHOR-Train-5229.scene_instance.json", + "./7/ProcTHOR-Train-5910.scene_instance.json", + "./7/ProcTHOR-Train-5945.scene_instance.json", + "./7/ProcTHOR-Train-5120.scene_instance.json", + "./7/ProcTHOR-Train-5039.scene_instance.json", + "./7/ProcTHOR-Train-5040.scene_instance.json", + "./7/ProcTHOR-Train-5620.scene_instance.json", + "./7/ProcTHOR-Train-5830.scene_instance.json", + "./7/ProcTHOR-Train-5856.scene_instance.json", + "./7/ProcTHOR-Train-5675.scene_instance.json", + "./7/ProcTHOR-Train-5580.scene_instance.json", + "./7/ProcTHOR-Train-5283.scene_instance.json", + "./7/ProcTHOR-Train-5259.scene_instance.json", + "./7/ProcTHOR-Train-5093.scene_instance.json", + "./7/ProcTHOR-Train-5595.scene_instance.json", + "./7/ProcTHOR-Train-5136.scene_instance.json", + "./7/ProcTHOR-Train-5681.scene_instance.json", + "./7/ProcTHOR-Train-5439.scene_instance.json", + "./7/ProcTHOR-Train-5884.scene_instance.json", + "./7/ProcTHOR-Train-5615.scene_instance.json", + "./7/ProcTHOR-Train-5963.scene_instance.json", + "./7/ProcTHOR-Train-5003.scene_instance.json", + "./7/ProcTHOR-Train-5576.scene_instance.json", + "./7/ProcTHOR-Train-5596.scene_instance.json", + "./7/ProcTHOR-Train-5461.scene_instance.json", + "./7/ProcTHOR-Train-5644.scene_instance.json", + "./7/ProcTHOR-Train-5065.scene_instance.json", + "./7/ProcTHOR-Train-5503.scene_instance.json", + "./7/ProcTHOR-Train-5781.scene_instance.json", + "./7/ProcTHOR-Train-5814.scene_instance.json", + "./7/ProcTHOR-Train-5188.scene_instance.json", + "./7/ProcTHOR-Train-5600.scene_instance.json", + "./7/ProcTHOR-Train-5285.scene_instance.json", + "./7/ProcTHOR-Train-5409.scene_instance.json", + "./7/ProcTHOR-Train-5160.scene_instance.json", + "./7/ProcTHOR-Train-5489.scene_instance.json", + "./7/ProcTHOR-Train-5138.scene_instance.json", + "./7/ProcTHOR-Train-5478.scene_instance.json", + "./7/ProcTHOR-Train-5651.scene_instance.json", + "./7/ProcTHOR-Train-5733.scene_instance.json", + "./7/ProcTHOR-Train-5764.scene_instance.json", + "./7/ProcTHOR-Train-5616.scene_instance.json", + "./7/ProcTHOR-Train-5775.scene_instance.json", + "./7/ProcTHOR-Train-5298.scene_instance.json", + "./7/ProcTHOR-Train-5591.scene_instance.json", + "./7/ProcTHOR-Train-5294.scene_instance.json", + "./7/ProcTHOR-Train-5482.scene_instance.json", + "./7/ProcTHOR-Train-5721.scene_instance.json", + "./7/ProcTHOR-Train-5730.scene_instance.json", + "./7/ProcTHOR-Train-5288.scene_instance.json", + "./7/ProcTHOR-Train-5452.scene_instance.json", + "./7/ProcTHOR-Train-5282.scene_instance.json", + "./7/ProcTHOR-Train-5494.scene_instance.json", + "./7/ProcTHOR-Train-5992.scene_instance.json", + "./7/ProcTHOR-Train-5547.scene_instance.json", + "./7/ProcTHOR-Train-5240.scene_instance.json", + "./7/ProcTHOR-Train-5145.scene_instance.json", + "./7/ProcTHOR-Train-5739.scene_instance.json", + "./7/ProcTHOR-Train-5649.scene_instance.json", + "./7/ProcTHOR-Train-5304.scene_instance.json", + "./7/ProcTHOR-Train-5777.scene_instance.json", + "./7/ProcTHOR-Train-5086.scene_instance.json", + "./7/ProcTHOR-Train-5973.scene_instance.json", + "./7/ProcTHOR-Train-5799.scene_instance.json", + "./7/ProcTHOR-Train-5046.scene_instance.json", + "./7/ProcTHOR-Train-5081.scene_instance.json", + "./7/ProcTHOR-Train-5516.scene_instance.json", + "./7/ProcTHOR-Train-5588.scene_instance.json", + "./7/ProcTHOR-Train-5313.scene_instance.json", + "./7/ProcTHOR-Train-5562.scene_instance.json", + "./7/ProcTHOR-Train-5099.scene_instance.json", + "./7/ProcTHOR-Train-5978.scene_instance.json", + "./7/ProcTHOR-Train-5805.scene_instance.json", + "./7/ProcTHOR-Train-5033.scene_instance.json", + "./7/ProcTHOR-Train-5094.scene_instance.json", + "./7/ProcTHOR-Train-5379.scene_instance.json", + "./7/ProcTHOR-Train-5823.scene_instance.json", + "./7/ProcTHOR-Train-5087.scene_instance.json", + "./7/ProcTHOR-Train-5251.scene_instance.json", + "./7/ProcTHOR-Train-5819.scene_instance.json", + "./7/ProcTHOR-Train-5105.scene_instance.json", + "./7/ProcTHOR-Train-5052.scene_instance.json", + "./7/ProcTHOR-Train-5384.scene_instance.json", + "./7/ProcTHOR-Train-5100.scene_instance.json", + "./7/ProcTHOR-Train-5829.scene_instance.json", + "./7/ProcTHOR-Train-5566.scene_instance.json", + "./7/ProcTHOR-Train-5951.scene_instance.json", + "./7/ProcTHOR-Train-5179.scene_instance.json", + "./7/ProcTHOR-Train-5828.scene_instance.json", + "./7/ProcTHOR-Train-5857.scene_instance.json", + "./7/ProcTHOR-Train-5454.scene_instance.json", + "./7/ProcTHOR-Train-5144.scene_instance.json", + "./7/ProcTHOR-Train-5791.scene_instance.json", + "./7/ProcTHOR-Train-5037.scene_instance.json", + "./7/ProcTHOR-Train-5124.scene_instance.json", + "./7/ProcTHOR-Train-5949.scene_instance.json", + "./7/ProcTHOR-Train-5895.scene_instance.json", + "./7/ProcTHOR-Train-5227.scene_instance.json", + "./7/ProcTHOR-Train-5691.scene_instance.json", + "./7/ProcTHOR-Train-5416.scene_instance.json", + "./7/ProcTHOR-Train-5677.scene_instance.json", + "./7/ProcTHOR-Train-5195.scene_instance.json", + "./7/ProcTHOR-Train-5472.scene_instance.json", + "./7/ProcTHOR-Train-5035.scene_instance.json", + "./7/ProcTHOR-Train-5911.scene_instance.json", + "./7/ProcTHOR-Train-5826.scene_instance.json", + "./7/ProcTHOR-Train-5462.scene_instance.json", + "./7/ProcTHOR-Train-5185.scene_instance.json", + "./7/ProcTHOR-Train-5385.scene_instance.json", + "./7/ProcTHOR-Train-5490.scene_instance.json", + "./7/ProcTHOR-Train-5180.scene_instance.json", + "./7/ProcTHOR-Train-5621.scene_instance.json", + "./7/ProcTHOR-Train-5442.scene_instance.json", + "./7/ProcTHOR-Train-5790.scene_instance.json", + "./7/ProcTHOR-Train-5329.scene_instance.json", + "./7/ProcTHOR-Train-5246.scene_instance.json", + "./7/ProcTHOR-Train-5944.scene_instance.json", + "./7/ProcTHOR-Train-5353.scene_instance.json", + "./7/ProcTHOR-Train-5636.scene_instance.json", + "./7/ProcTHOR-Train-5111.scene_instance.json", + "./7/ProcTHOR-Train-5833.scene_instance.json", + "./7/ProcTHOR-Train-5297.scene_instance.json", + "./7/ProcTHOR-Train-5015.scene_instance.json", + "./7/ProcTHOR-Train-5976.scene_instance.json", + "./7/ProcTHOR-Train-5038.scene_instance.json", + "./7/ProcTHOR-Train-5707.scene_instance.json", + "./7/ProcTHOR-Train-5835.scene_instance.json", + "./7/ProcTHOR-Train-5123.scene_instance.json", + "./7/ProcTHOR-Train-5751.scene_instance.json", + "./7/ProcTHOR-Train-5098.scene_instance.json", + "./7/ProcTHOR-Train-5007.scene_instance.json", + "./7/ProcTHOR-Train-5217.scene_instance.json", + "./7/ProcTHOR-Train-5460.scene_instance.json", + "./7/ProcTHOR-Train-5049.scene_instance.json", + "./7/ProcTHOR-Train-5892.scene_instance.json", + "./7/ProcTHOR-Train-5893.scene_instance.json", + "./7/ProcTHOR-Train-5528.scene_instance.json", + "./7/ProcTHOR-Train-5193.scene_instance.json", + "./7/ProcTHOR-Train-5716.scene_instance.json", + "./7/ProcTHOR-Train-5706.scene_instance.json", + "./7/ProcTHOR-Train-5738.scene_instance.json", + "./7/ProcTHOR-Train-5682.scene_instance.json", + "./7/ProcTHOR-Train-5604.scene_instance.json", + "./7/ProcTHOR-Train-5315.scene_instance.json", + "./7/ProcTHOR-Train-5723.scene_instance.json", + "./7/ProcTHOR-Train-5481.scene_instance.json", + "./7/ProcTHOR-Train-5643.scene_instance.json", + "./7/ProcTHOR-Train-5816.scene_instance.json", + "./7/ProcTHOR-Train-5523.scene_instance.json", + "./7/ProcTHOR-Train-5870.scene_instance.json", + "./7/ProcTHOR-Train-5821.scene_instance.json", + "./7/ProcTHOR-Train-5269.scene_instance.json", + "./7/ProcTHOR-Train-5981.scene_instance.json", + "./7/ProcTHOR-Train-5263.scene_instance.json", + "./7/ProcTHOR-Train-5612.scene_instance.json", + "./7/ProcTHOR-Train-5242.scene_instance.json", + "./7/ProcTHOR-Train-5034.scene_instance.json", + "./7/ProcTHOR-Train-5084.scene_instance.json", + "./7/ProcTHOR-Train-5809.scene_instance.json", + "./7/ProcTHOR-Train-5502.scene_instance.json", + "./7/ProcTHOR-Train-5533.scene_instance.json", + "./7/ProcTHOR-Train-5639.scene_instance.json", + "./7/ProcTHOR-Train-5513.scene_instance.json", + "./7/ProcTHOR-Train-5382.scene_instance.json", + "./7/ProcTHOR-Train-5641.scene_instance.json", + "./7/ProcTHOR-Train-5032.scene_instance.json", + "./7/ProcTHOR-Train-5451.scene_instance.json", + "./7/ProcTHOR-Train-5868.scene_instance.json", + "./7/ProcTHOR-Train-5901.scene_instance.json", + "./7/ProcTHOR-Train-5156.scene_instance.json", + "./7/ProcTHOR-Train-5252.scene_instance.json", + "./7/ProcTHOR-Train-5074.scene_instance.json", + "./7/ProcTHOR-Train-5559.scene_instance.json", + "./7/ProcTHOR-Train-5239.scene_instance.json", + "./7/ProcTHOR-Train-5866.scene_instance.json", + "./7/ProcTHOR-Train-5789.scene_instance.json", + "./7/ProcTHOR-Train-5176.scene_instance.json", + "./7/ProcTHOR-Train-5018.scene_instance.json", + "./7/ProcTHOR-Train-5115.scene_instance.json", + "./7/ProcTHOR-Train-5254.scene_instance.json", + "./7/ProcTHOR-Train-5877.scene_instance.json", + "./7/ProcTHOR-Train-5939.scene_instance.json", + "./7/ProcTHOR-Train-5380.scene_instance.json", + "./7/ProcTHOR-Train-5289.scene_instance.json", + "./7/ProcTHOR-Train-5824.scene_instance.json", + "./7/ProcTHOR-Train-5529.scene_instance.json", + "./7/ProcTHOR-Train-5786.scene_instance.json", + "./7/ProcTHOR-Train-5339.scene_instance.json", + "./7/ProcTHOR-Train-5418.scene_instance.json", + "./7/ProcTHOR-Train-5942.scene_instance.json", + "./7/ProcTHOR-Train-5563.scene_instance.json", + "./7/ProcTHOR-Train-5656.scene_instance.json", + "./7/ProcTHOR-Train-5519.scene_instance.json", + "./7/ProcTHOR-Train-5060.scene_instance.json", + "./7/ProcTHOR-Train-5359.scene_instance.json", + "./7/ProcTHOR-Train-5104.scene_instance.json", + "./7/ProcTHOR-Train-5411.scene_instance.json", + "./7/ProcTHOR-Train-5661.scene_instance.json", + "./7/ProcTHOR-Train-5832.scene_instance.json", + "./7/ProcTHOR-Train-5343.scene_instance.json", + "./7/ProcTHOR-Train-5869.scene_instance.json", + "./7/ProcTHOR-Train-5998.scene_instance.json", + "./7/ProcTHOR-Train-5163.scene_instance.json", + "./7/ProcTHOR-Train-5012.scene_instance.json", + "./7/ProcTHOR-Train-5112.scene_instance.json", + "./7/ProcTHOR-Train-5761.scene_instance.json", + "./7/ProcTHOR-Train-5363.scene_instance.json", + "./7/ProcTHOR-Train-5917.scene_instance.json", + "./7/ProcTHOR-Train-5396.scene_instance.json", + "./7/ProcTHOR-Train-5102.scene_instance.json", + "./7/ProcTHOR-Train-5922.scene_instance.json", + "./7/ProcTHOR-Train-5862.scene_instance.json", + "./7/ProcTHOR-Train-5550.scene_instance.json", + "./7/ProcTHOR-Train-5915.scene_instance.json", + "./7/ProcTHOR-Train-5330.scene_instance.json", + "./7/ProcTHOR-Train-5406.scene_instance.json", + "./7/ProcTHOR-Train-5320.scene_instance.json", + "./7/ProcTHOR-Train-5109.scene_instance.json", + "./7/ProcTHOR-Train-5028.scene_instance.json", + "./7/ProcTHOR-Train-5622.scene_instance.json", + "./7/ProcTHOR-Train-5057.scene_instance.json", + "./7/ProcTHOR-Train-5579.scene_instance.json", + "./7/ProcTHOR-Train-5053.scene_instance.json", + "./7/ProcTHOR-Train-5305.scene_instance.json", + "./7/ProcTHOR-Train-5314.scene_instance.json", + "./7/ProcTHOR-Train-5852.scene_instance.json", + "./7/ProcTHOR-Train-5820.scene_instance.json", + "./7/ProcTHOR-Train-5774.scene_instance.json", + "./7/ProcTHOR-Train-5212.scene_instance.json", + "./7/ProcTHOR-Train-5430.scene_instance.json", + "./7/ProcTHOR-Train-5127.scene_instance.json", + "./7/ProcTHOR-Train-5341.scene_instance.json", + "./7/ProcTHOR-Train-5552.scene_instance.json", + "./7/ProcTHOR-Train-5173.scene_instance.json", + "./7/ProcTHOR-Train-5962.scene_instance.json", + "./7/ProcTHOR-Train-5101.scene_instance.json", + "./7/ProcTHOR-Train-5197.scene_instance.json", + "./7/ProcTHOR-Train-5545.scene_instance.json", + "./7/ProcTHOR-Train-5969.scene_instance.json", + "./7/ProcTHOR-Train-5628.scene_instance.json", + "./7/ProcTHOR-Train-5701.scene_instance.json", + "./7/ProcTHOR-Train-5798.scene_instance.json", + "./7/ProcTHOR-Train-5358.scene_instance.json", + "./7/ProcTHOR-Train-5350.scene_instance.json", + "./7/ProcTHOR-Train-5982.scene_instance.json", + "./7/ProcTHOR-Train-5184.scene_instance.json", + "./7/ProcTHOR-Train-5843.scene_instance.json", + "./7/ProcTHOR-Train-5402.scene_instance.json", + "./7/ProcTHOR-Train-5005.scene_instance.json", + "./7/ProcTHOR-Train-5257.scene_instance.json", + "./7/ProcTHOR-Train-5804.scene_instance.json", + "./7/ProcTHOR-Train-5650.scene_instance.json", + "./7/ProcTHOR-Train-5634.scene_instance.json", + "./7/ProcTHOR-Train-5500.scene_instance.json", + "./7/ProcTHOR-Train-5768.scene_instance.json", + "./7/ProcTHOR-Train-5372.scene_instance.json", + "./7/ProcTHOR-Train-5964.scene_instance.json", + "./7/ProcTHOR-Train-5770.scene_instance.json", + "./7/ProcTHOR-Train-5427.scene_instance.json", + "./7/ProcTHOR-Train-5213.scene_instance.json", + "./7/ProcTHOR-Train-5625.scene_instance.json", + "./7/ProcTHOR-Train-5389.scene_instance.json", + "./7/ProcTHOR-Train-5645.scene_instance.json", + "./7/ProcTHOR-Train-5437.scene_instance.json", + "./7/ProcTHOR-Train-5750.scene_instance.json", + "./7/ProcTHOR-Train-5244.scene_instance.json", + "./7/ProcTHOR-Train-5022.scene_instance.json", + "./7/ProcTHOR-Train-5440.scene_instance.json", + "./7/ProcTHOR-Train-5514.scene_instance.json", + "./7/ProcTHOR-Train-5118.scene_instance.json", + "./7/ProcTHOR-Train-5030.scene_instance.json", + "./7/ProcTHOR-Train-5221.scene_instance.json", + "./7/ProcTHOR-Train-5296.scene_instance.json", + "./7/ProcTHOR-Train-5613.scene_instance.json", + "./7/ProcTHOR-Train-5493.scene_instance.json", + "./7/ProcTHOR-Train-5024.scene_instance.json", + "./7/ProcTHOR-Train-5253.scene_instance.json", + "./7/ProcTHOR-Train-5412.scene_instance.json", + "./7/ProcTHOR-Train-5825.scene_instance.json", + "./7/ProcTHOR-Train-5182.scene_instance.json", + "./7/ProcTHOR-Train-5720.scene_instance.json", + "./7/ProcTHOR-Train-5377.scene_instance.json", + "./7/ProcTHOR-Train-5765.scene_instance.json", + "./7/ProcTHOR-Train-5737.scene_instance.json", + "./7/ProcTHOR-Train-5400.scene_instance.json", + "./7/ProcTHOR-Train-5837.scene_instance.json", + "./7/ProcTHOR-Train-5551.scene_instance.json", + "./7/ProcTHOR-Train-5948.scene_instance.json", + "./7/ProcTHOR-Train-5549.scene_instance.json", + "./7/ProcTHOR-Train-5872.scene_instance.json", + "./7/ProcTHOR-Train-5137.scene_instance.json", + "./7/ProcTHOR-Train-5966.scene_instance.json", + "./7/ProcTHOR-Train-5293.scene_instance.json", + "./7/ProcTHOR-Train-5006.scene_instance.json", + "./7/ProcTHOR-Train-5584.scene_instance.json", + "./7/ProcTHOR-Train-5882.scene_instance.json", + "./7/ProcTHOR-Train-5079.scene_instance.json", + "./7/ProcTHOR-Train-5223.scene_instance.json", + "./7/ProcTHOR-Train-5674.scene_instance.json", + "./7/ProcTHOR-Train-5347.scene_instance.json", + "./7/ProcTHOR-Train-5080.scene_instance.json", + "./7/ProcTHOR-Train-5953.scene_instance.json", + "./7/ProcTHOR-Train-5993.scene_instance.json", + "./7/ProcTHOR-Train-5899.scene_instance.json", + "./7/ProcTHOR-Train-5885.scene_instance.json", + "./7/ProcTHOR-Train-5687.scene_instance.json", + "./7/ProcTHOR-Train-5459.scene_instance.json", + "./7/ProcTHOR-Train-5307.scene_instance.json", + "./7/ProcTHOR-Train-5606.scene_instance.json", + "./7/ProcTHOR-Train-5592.scene_instance.json", + "./7/ProcTHOR-Train-5714.scene_instance.json", + "./7/ProcTHOR-Train-5467.scene_instance.json", + "./7/ProcTHOR-Train-5441.scene_instance.json", + "./7/ProcTHOR-Train-5428.scene_instance.json", + "./7/ProcTHOR-Train-5011.scene_instance.json", + "./7/ProcTHOR-Train-5984.scene_instance.json", + "./7/ProcTHOR-Train-5174.scene_instance.json", + "./7/ProcTHOR-Train-5890.scene_instance.json", + "./7/ProcTHOR-Train-5916.scene_instance.json", + "./7/ProcTHOR-Train-5842.scene_instance.json", + "./7/ProcTHOR-Train-5364.scene_instance.json", + "./7/ProcTHOR-Train-5736.scene_instance.json", + "./7/ProcTHOR-Train-5463.scene_instance.json", + "./7/ProcTHOR-Train-5663.scene_instance.json", + "./7/ProcTHOR-Train-5980.scene_instance.json", + "./7/ProcTHOR-Train-5907.scene_instance.json", + "./7/ProcTHOR-Train-5029.scene_instance.json", + "./7/ProcTHOR-Train-5162.scene_instance.json", + "./7/ProcTHOR-Train-5527.scene_instance.json", + "./7/ProcTHOR-Train-5480.scene_instance.json", + "./7/ProcTHOR-Train-5554.scene_instance.json", + "./7/ProcTHOR-Train-5959.scene_instance.json", + "./7/ProcTHOR-Train-5724.scene_instance.json", + "./7/ProcTHOR-Train-5222.scene_instance.json", + "./7/ProcTHOR-Train-5299.scene_instance.json", + "./7/ProcTHOR-Train-5934.scene_instance.json", + "./7/ProcTHOR-Train-5371.scene_instance.json", + "./7/ProcTHOR-Train-5538.scene_instance.json", + "./7/ProcTHOR-Train-5673.scene_instance.json", + "./7/ProcTHOR-Train-5728.scene_instance.json", + "./7/ProcTHOR-Train-5704.scene_instance.json", + "./7/ProcTHOR-Train-5317.scene_instance.json", + "./7/ProcTHOR-Train-5535.scene_instance.json", + "./7/ProcTHOR-Train-5407.scene_instance.json", + "./7/ProcTHOR-Train-5676.scene_instance.json", + "./7/ProcTHOR-Train-5861.scene_instance.json", + "./7/ProcTHOR-Train-5091.scene_instance.json", + "./7/ProcTHOR-Train-5947.scene_instance.json", + "./7/ProcTHOR-Train-5367.scene_instance.json", + "./7/ProcTHOR-Train-5300.scene_instance.json", + "./7/ProcTHOR-Train-5695.scene_instance.json", + "./7/ProcTHOR-Train-5153.scene_instance.json", + "./7/ProcTHOR-Train-5508.scene_instance.json", + "./7/ProcTHOR-Train-5374.scene_instance.json", + "./7/ProcTHOR-Train-5902.scene_instance.json", + "./7/ProcTHOR-Train-5432.scene_instance.json", + "./7/ProcTHOR-Train-5912.scene_instance.json", + "./7/ProcTHOR-Train-5952.scene_instance.json", + "./7/ProcTHOR-Train-5054.scene_instance.json", + "./7/ProcTHOR-Train-5175.scene_instance.json", + "./7/ProcTHOR-Train-5539.scene_instance.json", + "./7/ProcTHOR-Train-5709.scene_instance.json", + "./7/ProcTHOR-Train-5260.scene_instance.json", + "./7/ProcTHOR-Train-5391.scene_instance.json", + "./7/ProcTHOR-Train-5954.scene_instance.json", + "./7/ProcTHOR-Train-5164.scene_instance.json", + "./7/ProcTHOR-Train-5987.scene_instance.json", + "./7/ProcTHOR-Train-5589.scene_instance.json", + "./7/ProcTHOR-Train-5431.scene_instance.json", + "./7/ProcTHOR-Train-5354.scene_instance.json", + "./7/ProcTHOR-Train-5657.scene_instance.json", + "./7/ProcTHOR-Train-5710.scene_instance.json", + "./7/ProcTHOR-Train-5572.scene_instance.json", + "./7/ProcTHOR-Train-5332.scene_instance.json", + "./7/ProcTHOR-Train-5456.scene_instance.json", + "./7/ProcTHOR-Train-5369.scene_instance.json", + "./7/ProcTHOR-Train-5073.scene_instance.json", + "./7/ProcTHOR-Train-5795.scene_instance.json", + "./7/ProcTHOR-Train-5515.scene_instance.json", + "./7/ProcTHOR-Train-5807.scene_instance.json", + "./7/ProcTHOR-Train-5960.scene_instance.json", + "./7/ProcTHOR-Train-5627.scene_instance.json", + "./7/ProcTHOR-Train-5755.scene_instance.json", + "./7/ProcTHOR-Train-5215.scene_instance.json", + "./7/ProcTHOR-Train-5287.scene_instance.json", + "./7/ProcTHOR-Train-5154.scene_instance.json", + "./7/ProcTHOR-Train-5445.scene_instance.json", + "./7/ProcTHOR-Train-5874.scene_instance.json", + "./7/ProcTHOR-Train-5150.scene_instance.json", + "./7/ProcTHOR-Train-5484.scene_instance.json", + "./7/ProcTHOR-Train-5611.scene_instance.json", + "./7/ProcTHOR-Train-5722.scene_instance.json", + "./7/ProcTHOR-Train-5512.scene_instance.json", + "./7/ProcTHOR-Train-5158.scene_instance.json", + "./7/ProcTHOR-Train-5001.scene_instance.json", + "./7/ProcTHOR-Train-5201.scene_instance.json", + "./7/ProcTHOR-Train-5668.scene_instance.json", + "./7/ProcTHOR-Train-5753.scene_instance.json", + "./7/ProcTHOR-Train-5061.scene_instance.json", + "./7/ProcTHOR-Train-5245.scene_instance.json", + "./7/ProcTHOR-Train-5360.scene_instance.json", + "./7/ProcTHOR-Train-5471.scene_instance.json", + "./7/ProcTHOR-Train-5233.scene_instance.json", + "./7/ProcTHOR-Train-5637.scene_instance.json", + "./7/ProcTHOR-Train-5731.scene_instance.json", + "./7/ProcTHOR-Train-5849.scene_instance.json", + "./7/ProcTHOR-Train-5077.scene_instance.json", + "./7/ProcTHOR-Train-5468.scene_instance.json", + "./7/ProcTHOR-Train-5113.scene_instance.json", + "./7/ProcTHOR-Train-5116.scene_instance.json", + "./7/ProcTHOR-Train-5501.scene_instance.json", + "./7/ProcTHOR-Train-5601.scene_instance.json", + "./7/ProcTHOR-Train-5301.scene_instance.json", + "./7/ProcTHOR-Train-5717.scene_instance.json", + "./7/ProcTHOR-Train-5567.scene_instance.json", + "./7/ProcTHOR-Train-5836.scene_instance.json", + "./7/ProcTHOR-Train-5132.scene_instance.json", + "./7/ProcTHOR-Train-5583.scene_instance.json", + "./7/ProcTHOR-Train-5157.scene_instance.json", + "./7/ProcTHOR-Train-5812.scene_instance.json", + "./7/ProcTHOR-Train-5762.scene_instance.json", + "./7/ProcTHOR-Train-5848.scene_instance.json", + "./7/ProcTHOR-Train-5394.scene_instance.json", + "./7/ProcTHOR-Train-5019.scene_instance.json", + "./7/ProcTHOR-Train-5909.scene_instance.json", + "./7/ProcTHOR-Train-5510.scene_instance.json", + "./7/ProcTHOR-Train-5967.scene_instance.json", + "./7/ProcTHOR-Train-5773.scene_instance.json", + "./7/ProcTHOR-Train-5970.scene_instance.json", + "./7/ProcTHOR-Train-5340.scene_instance.json", + "./7/ProcTHOR-Train-5997.scene_instance.json", + "./7/ProcTHOR-Train-5713.scene_instance.json", + "./7/ProcTHOR-Train-5853.scene_instance.json", + "./7/ProcTHOR-Train-5806.scene_instance.json", + "./7/ProcTHOR-Train-5485.scene_instance.json", + "./7/ProcTHOR-Train-5968.scene_instance.json", + "./7/ProcTHOR-Train-5965.scene_instance.json", + "./7/ProcTHOR-Train-5211.scene_instance.json", + "./7/ProcTHOR-Train-5802.scene_instance.json", + "./7/ProcTHOR-Train-5168.scene_instance.json", + "./7/ProcTHOR-Train-5543.scene_instance.json", + "./7/ProcTHOR-Train-5633.scene_instance.json", + "./7/ProcTHOR-Train-5436.scene_instance.json", + "./7/ProcTHOR-Train-5818.scene_instance.json", + "./7/ProcTHOR-Train-5603.scene_instance.json", + "./7/ProcTHOR-Train-5090.scene_instance.json", + "./7/ProcTHOR-Train-5284.scene_instance.json", + "./7/ProcTHOR-Train-5141.scene_instance.json", + "./7/ProcTHOR-Train-5387.scene_instance.json", + "./7/ProcTHOR-Train-5368.scene_instance.json", + "./7/ProcTHOR-Train-5847.scene_instance.json", + "./7/ProcTHOR-Train-5059.scene_instance.json", + "./7/ProcTHOR-Train-5943.scene_instance.json", + "./7/ProcTHOR-Train-5564.scene_instance.json", + "./7/ProcTHOR-Train-5398.scene_instance.json", + "./7/ProcTHOR-Train-5335.scene_instance.json", + "./7/ProcTHOR-Train-5149.scene_instance.json", + "./7/ProcTHOR-Train-5703.scene_instance.json", + "./7/ProcTHOR-Train-5929.scene_instance.json", + "./7/ProcTHOR-Train-5863.scene_instance.json", + "./7/ProcTHOR-Train-5570.scene_instance.json", + "./7/ProcTHOR-Train-5333.scene_instance.json", + "./7/ProcTHOR-Train-5410.scene_instance.json", + "./7/ProcTHOR-Train-5433.scene_instance.json", + "./7/ProcTHOR-Train-5277.scene_instance.json", + "./7/ProcTHOR-Train-5477.scene_instance.json", + "./7/ProcTHOR-Train-5708.scene_instance.json", + "./7/ProcTHOR-Train-5042.scene_instance.json", + "./7/ProcTHOR-Train-5423.scene_instance.json", + "./7/ProcTHOR-Train-5392.scene_instance.json", + "./7/ProcTHOR-Train-5135.scene_instance.json", + "./7/ProcTHOR-Train-5754.scene_instance.json", + "./7/ProcTHOR-Train-5278.scene_instance.json", + "./7/ProcTHOR-Train-5598.scene_instance.json", + "./7/ProcTHOR-Train-5803.scene_instance.json", + "./7/ProcTHOR-Train-5218.scene_instance.json", + "./7/ProcTHOR-Train-5465.scene_instance.json", + "./7/ProcTHOR-Train-5760.scene_instance.json", + "./7/ProcTHOR-Train-5532.scene_instance.json", + "./7/ProcTHOR-Train-5878.scene_instance.json", + "./7/ProcTHOR-Train-5457.scene_instance.json", + "./7/ProcTHOR-Train-5270.scene_instance.json", + "./7/ProcTHOR-Train-5324.scene_instance.json", + "./7/ProcTHOR-Train-5237.scene_instance.json", + "./7/ProcTHOR-Train-5851.scene_instance.json", + "./7/ProcTHOR-Train-5204.scene_instance.json", + "./7/ProcTHOR-Train-5957.scene_instance.json", + "./7/ProcTHOR-Train-5151.scene_instance.json", + "./7/ProcTHOR-Train-5256.scene_instance.json", + "./7/ProcTHOR-Train-5322.scene_instance.json", + "./7/ProcTHOR-Train-5408.scene_instance.json", + "./7/ProcTHOR-Train-5683.scene_instance.json", + "./7/ProcTHOR-Train-5593.scene_instance.json", + "./7/ProcTHOR-Train-5479.scene_instance.json", + "./7/ProcTHOR-Train-5470.scene_instance.json", + "./7/ProcTHOR-Train-5208.scene_instance.json", + "./7/ProcTHOR-Train-5126.scene_instance.json", + "./7/ProcTHOR-Train-5748.scene_instance.json", + "./7/ProcTHOR-Train-5785.scene_instance.json", + "./7/ProcTHOR-Train-5236.scene_instance.json", + "./7/ProcTHOR-Train-5725.scene_instance.json", + "./7/ProcTHOR-Train-5498.scene_instance.json", + "./7/ProcTHOR-Train-5316.scene_instance.json", + "./7/ProcTHOR-Train-5534.scene_instance.json", + "./7/ProcTHOR-Train-5342.scene_instance.json", + "./7/ProcTHOR-Train-5186.scene_instance.json", + "./7/ProcTHOR-Train-5178.scene_instance.json", + "./7/ProcTHOR-Train-5900.scene_instance.json", + "./7/ProcTHOR-Train-5925.scene_instance.json", + "./7/ProcTHOR-Train-5274.scene_instance.json", + "./7/ProcTHOR-Train-5702.scene_instance.json", + "./7/ProcTHOR-Train-5961.scene_instance.json", + "./7/ProcTHOR-Train-5845.scene_instance.json", + "./7/ProcTHOR-Train-5327.scene_instance.json", + "./7/ProcTHOR-Train-5159.scene_instance.json", + "./7/ProcTHOR-Train-5594.scene_instance.json", + "./7/ProcTHOR-Train-5697.scene_instance.json", + "./7/ProcTHOR-Train-5232.scene_instance.json", + "./7/ProcTHOR-Train-5642.scene_instance.json", + "./7/ProcTHOR-Train-5110.scene_instance.json", + "./7/ProcTHOR-Train-5555.scene_instance.json", + "./7/ProcTHOR-Train-5121.scene_instance.json", + "./7/ProcTHOR-Train-5927.scene_instance.json", + "./7/ProcTHOR-Train-5653.scene_instance.json", + "./7/ProcTHOR-Train-5421.scene_instance.json", + "./7/ProcTHOR-Train-5010.scene_instance.json", + "./7/ProcTHOR-Train-5972.scene_instance.json", + "./7/ProcTHOR-Train-5617.scene_instance.json", + "./7/ProcTHOR-Train-5453.scene_instance.json", + "./7/ProcTHOR-Train-5131.scene_instance.json", + "./7/ProcTHOR-Train-5473.scene_instance.json", + "./7/ProcTHOR-Train-5450.scene_instance.json", + "./7/ProcTHOR-Train-5280.scene_instance.json", + "./7/ProcTHOR-Train-5261.scene_instance.json", + "./7/ProcTHOR-Train-5793.scene_instance.json", + "./7/ProcTHOR-Train-5165.scene_instance.json", + "./7/ProcTHOR-Train-5207.scene_instance.json", + "./7/ProcTHOR-Train-5887.scene_instance.json", + "./7/ProcTHOR-Train-5568.scene_instance.json", + "./7/ProcTHOR-Train-5291.scene_instance.json", + "./7/ProcTHOR-Train-5474.scene_instance.json", + "./7/ProcTHOR-Train-5355.scene_instance.json", + "./7/ProcTHOR-Train-5903.scene_instance.json", + "./7/ProcTHOR-Train-5623.scene_instance.json", + "./7/ProcTHOR-Train-5219.scene_instance.json", + "./7/ProcTHOR-Train-5092.scene_instance.json", + "./7/ProcTHOR-Train-5026.scene_instance.json", + "./7/ProcTHOR-Train-5238.scene_instance.json", + "./7/ProcTHOR-Train-5719.scene_instance.json", + "./7/ProcTHOR-Train-5995.scene_instance.json", + "./7/ProcTHOR-Train-5659.scene_instance.json", + "./7/ProcTHOR-Train-5147.scene_instance.json", + "./7/ProcTHOR-Train-5787.scene_instance.json", + "./7/ProcTHOR-Train-5822.scene_instance.json", + "./7/ProcTHOR-Train-5763.scene_instance.json", + "./7/ProcTHOR-Train-5602.scene_instance.json", + "./7/ProcTHOR-Train-5183.scene_instance.json", + "./7/ProcTHOR-Train-5582.scene_instance.json", + "./7/ProcTHOR-Train-5924.scene_instance.json", + "./7/ProcTHOR-Train-5780.scene_instance.json", + "./7/ProcTHOR-Train-5422.scene_instance.json", + "./7/ProcTHOR-Train-5794.scene_instance.json", + "./7/ProcTHOR-Train-5838.scene_instance.json", + "./7/ProcTHOR-Train-5443.scene_instance.json", + "./7/ProcTHOR-Train-5393.scene_instance.json", + "./7/ProcTHOR-Train-5544.scene_instance.json", + "./7/ProcTHOR-Train-5383.scene_instance.json", + "./7/ProcTHOR-Train-5575.scene_instance.json", + "./7/ProcTHOR-Train-5133.scene_instance.json", + "./7/ProcTHOR-Train-5466.scene_instance.json", + "./7/ProcTHOR-Train-5308.scene_instance.json", + "./7/ProcTHOR-Train-5607.scene_instance.json", + "./7/ProcTHOR-Train-5063.scene_instance.json", + "./7/ProcTHOR-Train-5897.scene_instance.json", + "./7/ProcTHOR-Train-5896.scene_instance.json", + "./7/ProcTHOR-Train-5614.scene_instance.json", + "./7/ProcTHOR-Train-5142.scene_instance.json", + "./7/ProcTHOR-Train-5783.scene_instance.json", + "./7/ProcTHOR-Train-5390.scene_instance.json", + "./7/ProcTHOR-Train-5205.scene_instance.json", + "./7/ProcTHOR-Train-5646.scene_instance.json", + "./7/ProcTHOR-Train-5388.scene_instance.json", + "./7/ProcTHOR-Train-5776.scene_instance.json", + "./7/ProcTHOR-Train-5344.scene_instance.json", + "./7/ProcTHOR-Train-5672.scene_instance.json", + "./7/ProcTHOR-Train-5365.scene_instance.json", + "./7/ProcTHOR-Train-5129.scene_instance.json", + "./7/ProcTHOR-Train-5066.scene_instance.json", + "./7/ProcTHOR-Train-5386.scene_instance.json", + "./7/ProcTHOR-Train-5055.scene_instance.json", + "./7/ProcTHOR-Train-5216.scene_instance.json", + "./7/ProcTHOR-Train-5782.scene_instance.json", + "./7/ProcTHOR-Train-5310.scene_instance.json", + "./7/ProcTHOR-Train-5414.scene_instance.json", + "./7/ProcTHOR-Train-5290.scene_instance.json", + "./7/ProcTHOR-Train-5618.scene_instance.json", + "./7/ProcTHOR-Train-5690.scene_instance.json", + "./7/ProcTHOR-Train-5577.scene_instance.json", + "./7/ProcTHOR-Train-5345.scene_instance.json", + "./7/ProcTHOR-Train-5522.scene_instance.json", + "./7/ProcTHOR-Train-5435.scene_instance.json", + "./7/ProcTHOR-Train-5321.scene_instance.json", + "./7/ProcTHOR-Train-5499.scene_instance.json", + "./7/ProcTHOR-Train-5114.scene_instance.json", + "./7/ProcTHOR-Train-5243.scene_instance.json", + "./7/ProcTHOR-Train-5700.scene_instance.json", + "./7/ProcTHOR-Train-5727.scene_instance.json", + "./7/ProcTHOR-Train-5075.scene_instance.json", + "./7/ProcTHOR-Train-5023.scene_instance.json", + "./7/ProcTHOR-Train-5376.scene_instance.json", + "./7/ProcTHOR-Train-5273.scene_instance.json", + "./7/ProcTHOR-Train-5557.scene_instance.json", + "./7/ProcTHOR-Train-5517.scene_instance.json", + "./7/ProcTHOR-Train-5196.scene_instance.json", + "./7/ProcTHOR-Train-5085.scene_instance.json", + "./7/ProcTHOR-Train-5696.scene_instance.json", + "./7/ProcTHOR-Train-5734.scene_instance.json", + "./7/ProcTHOR-Train-5873.scene_instance.json", + "./7/ProcTHOR-Train-5326.scene_instance.json", + "./7/ProcTHOR-Train-5605.scene_instance.json", + "./7/ProcTHOR-Train-5509.scene_instance.json", + "./7/ProcTHOR-Train-5574.scene_instance.json", + "./7/ProcTHOR-Train-5854.scene_instance.json", + "./7/ProcTHOR-Train-5524.scene_instance.json", + "./7/ProcTHOR-Train-5938.scene_instance.json", + "./7/ProcTHOR-Train-5190.scene_instance.json", + "./7/ProcTHOR-Train-5827.scene_instance.json", + "./7/ProcTHOR-Train-5769.scene_instance.json", + "./7/ProcTHOR-Train-5002.scene_instance.json", + "./7/ProcTHOR-Train-5920.scene_instance.json", + "./7/ProcTHOR-Train-5740.scene_instance.json", + "./7/ProcTHOR-Train-5743.scene_instance.json", + "./7/ProcTHOR-Train-5469.scene_instance.json", + "./7/ProcTHOR-Train-5974.scene_instance.json", + "./7/ProcTHOR-Train-5797.scene_instance.json", + "./7/ProcTHOR-Train-5689.scene_instance.json", + "./7/ProcTHOR-Train-5375.scene_instance.json", + "./7/ProcTHOR-Train-5357.scene_instance.json", + "./7/ProcTHOR-Train-5801.scene_instance.json", + "./7/ProcTHOR-Train-5652.scene_instance.json", + "./7/ProcTHOR-Train-5784.scene_instance.json", + "./7/ProcTHOR-Train-5875.scene_instance.json", + "./7/ProcTHOR-Train-5082.scene_instance.json", + "./7/ProcTHOR-Train-5434.scene_instance.json", + "./7/ProcTHOR-Train-5319.scene_instance.json", + "./7/ProcTHOR-Train-5309.scene_instance.json", + "./7/ProcTHOR-Train-5926.scene_instance.json", + "./7/ProcTHOR-Train-5194.scene_instance.json", + "./7/ProcTHOR-Train-5155.scene_instance.json", + "./7/ProcTHOR-Train-5248.scene_instance.json", + "./7/ProcTHOR-Train-5247.scene_instance.json", + "./7/ProcTHOR-Train-5292.scene_instance.json", + "./7/ProcTHOR-Train-5108.scene_instance.json", + "./7/ProcTHOR-Train-5312.scene_instance.json", + "./7/ProcTHOR-Train-5008.scene_instance.json", + "./7/ProcTHOR-Train-5766.scene_instance.json", + "./7/ProcTHOR-Train-5684.scene_instance.json", + "./7/ProcTHOR-Train-5050.scene_instance.json", + "./7/ProcTHOR-Train-5908.scene_instance.json", + "./7/ProcTHOR-Train-5542.scene_instance.json", + "./7/ProcTHOR-Train-5272.scene_instance.json", + "./7/ProcTHOR-Train-5664.scene_instance.json", + "./7/ProcTHOR-Train-5231.scene_instance.json", + "./7/ProcTHOR-Train-5241.scene_instance.json", + "./7/ProcTHOR-Train-5234.scene_instance.json", + "./7/ProcTHOR-Train-5840.scene_instance.json", + "./7/ProcTHOR-Train-5036.scene_instance.json", + "./7/ProcTHOR-Train-5671.scene_instance.json", + "./7/ProcTHOR-Train-5378.scene_instance.json", + "./7/ProcTHOR-Train-5265.scene_instance.json", + "./7/ProcTHOR-Train-5214.scene_instance.json", + "./7/ProcTHOR-Train-5262.scene_instance.json", + "./7/ProcTHOR-Train-5475.scene_instance.json", + "./7/ProcTHOR-Train-5424.scene_instance.json", + "./7/ProcTHOR-Train-5698.scene_instance.json", + "./7/ProcTHOR-Train-5224.scene_instance.json", + "./7/ProcTHOR-Train-5894.scene_instance.json", + "./7/ProcTHOR-Train-5541.scene_instance.json", + "./7/ProcTHOR-Train-5507.scene_instance.json", + "./7/ProcTHOR-Train-5746.scene_instance.json", + "./7/ProcTHOR-Train-5889.scene_instance.json", + "./7/ProcTHOR-Train-5936.scene_instance.json", + "./7/ProcTHOR-Train-5348.scene_instance.json", + "./7/ProcTHOR-Train-5027.scene_instance.json", + "./7/ProcTHOR-Train-5526.scene_instance.json", + "./7/ProcTHOR-Train-5009.scene_instance.json", + "./7/ProcTHOR-Train-5693.scene_instance.json", + "./7/ProcTHOR-Train-5932.scene_instance.json", + "./7/ProcTHOR-Train-5599.scene_instance.json", + "./7/ProcTHOR-Train-5955.scene_instance.json", + "./7/ProcTHOR-Train-5014.scene_instance.json", + "./7/ProcTHOR-Train-5119.scene_instance.json", + "./7/ProcTHOR-Train-5525.scene_instance.json", + "./7/ProcTHOR-Train-5928.scene_instance.json", + "./7/ProcTHOR-Train-5438.scene_instance.json", + "./7/ProcTHOR-Train-5311.scene_instance.json", + "./7/ProcTHOR-Train-5486.scene_instance.json", + "./7/ProcTHOR-Train-5230.scene_instance.json", + "./7/ProcTHOR-Train-5752.scene_instance.json", + "./7/ProcTHOR-Train-5306.scene_instance.json", + "./7/ProcTHOR-Train-5189.scene_instance.json", + "./7/ProcTHOR-Train-5495.scene_instance.json", + "./7/ProcTHOR-Train-5918.scene_instance.json", + "./7/ProcTHOR-Train-5635.scene_instance.json", + "./7/ProcTHOR-Train-5778.scene_instance.json", + "./7/ProcTHOR-Train-5670.scene_instance.json", + "./7/ProcTHOR-Train-5990.scene_instance.json", + "./7/ProcTHOR-Train-5983.scene_instance.json", + "./7/ProcTHOR-Train-5403.scene_instance.json", + "./7/ProcTHOR-Train-5546.scene_instance.json", + "./7/ProcTHOR-Train-5286.scene_instance.json", + "./7/ProcTHOR-Train-5742.scene_instance.json", + "./7/ProcTHOR-Train-5867.scene_instance.json", + "./7/ProcTHOR-Train-5476.scene_instance.json", + "./7/ProcTHOR-Train-5420.scene_instance.json", + "./7/ProcTHOR-Train-5540.scene_instance.json", + "./7/ProcTHOR-Train-5518.scene_instance.json", + "./7/ProcTHOR-Train-5170.scene_instance.json", + "./7/ProcTHOR-Train-5491.scene_instance.json", + "./7/ProcTHOR-Train-5464.scene_instance.json", + "./7/ProcTHOR-Train-5979.scene_instance.json", + "./7/ProcTHOR-Train-5624.scene_instance.json", + "./7/ProcTHOR-Train-5140.scene_instance.json", + "./7/ProcTHOR-Train-5883.scene_instance.json", + "./7/ProcTHOR-Train-5844.scene_instance.json", + "./7/ProcTHOR-Train-5608.scene_instance.json", + "./7/ProcTHOR-Train-5172.scene_instance.json", + "./7/ProcTHOR-Train-5771.scene_instance.json", + "./7/ProcTHOR-Train-5395.scene_instance.json", + "./7/ProcTHOR-Train-5808.scene_instance.json", + "./7/ProcTHOR-Train-5041.scene_instance.json", + "./7/ProcTHOR-Train-5531.scene_instance.json", + "./7/ProcTHOR-Train-5043.scene_instance.json", + "./7/ProcTHOR-Train-5349.scene_instance.json", + "./7/ProcTHOR-Train-5767.scene_instance.json", + "./7/ProcTHOR-Train-5834.scene_instance.json", + "./7/ProcTHOR-Train-5505.scene_instance.json", + "./7/ProcTHOR-Train-5264.scene_instance.json", + "./7/ProcTHOR-Train-5225.scene_instance.json", + "./7/ProcTHOR-Train-5553.scene_instance.json", + "./7/ProcTHOR-Train-5045.scene_instance.json", + "./7/ProcTHOR-Train-5586.scene_instance.json", + "./7/ProcTHOR-Train-5072.scene_instance.json", + "./7/ProcTHOR-Train-5169.scene_instance.json", + "./7/ProcTHOR-Train-5397.scene_instance.json", + "./7/ProcTHOR-Train-5148.scene_instance.json", + "./7/ProcTHOR-Train-5088.scene_instance.json", + "./7/ProcTHOR-Train-5455.scene_instance.json", + "./7/ProcTHOR-Train-5711.scene_instance.json", + "./7/ProcTHOR-Train-5496.scene_instance.json", + "./7/ProcTHOR-Train-5811.scene_instance.json", + "./7/ProcTHOR-Train-5569.scene_instance.json", + "./7/ProcTHOR-Train-5448.scene_instance.json", + "./7/ProcTHOR-Train-5504.scene_instance.json", + "./7/ProcTHOR-Train-5665.scene_instance.json", + "./7/ProcTHOR-Train-5841.scene_instance.json", + "./7/ProcTHOR-Train-5139.scene_instance.json", + "./7/ProcTHOR-Train-5209.scene_instance.json", + "./7/ProcTHOR-Train-5067.scene_instance.json", + "./7/ProcTHOR-Train-5078.scene_instance.json", + "./7/ProcTHOR-Train-5483.scene_instance.json", + "./7/ProcTHOR-Train-5492.scene_instance.json", + "./7/ProcTHOR-Train-5268.scene_instance.json", + "./7/ProcTHOR-Train-5228.scene_instance.json", + "./7/ProcTHOR-Train-5107.scene_instance.json", + "./7/ProcTHOR-Train-5629.scene_instance.json", + "./7/ProcTHOR-Train-5881.scene_instance.json", + "./7/ProcTHOR-Train-5573.scene_instance.json", + "./7/ProcTHOR-Train-5991.scene_instance.json", + "./7/ProcTHOR-Train-5536.scene_instance.json", + "./7/ProcTHOR-Train-5578.scene_instance.json", + "./7/ProcTHOR-Train-5419.scene_instance.json", + "./7/ProcTHOR-Train-5660.scene_instance.json", + "./7/ProcTHOR-Train-5975.scene_instance.json", + "./7/ProcTHOR-Train-5876.scene_instance.json", + "./7/ProcTHOR-Train-5839.scene_instance.json", + "./7/ProcTHOR-Train-5275.scene_instance.json", + "./7/ProcTHOR-Train-5757.scene_instance.json", + "./7/ProcTHOR-Train-5888.scene_instance.json", + "./7/ProcTHOR-Train-5694.scene_instance.json", + "./7/ProcTHOR-Train-5004.scene_instance.json", + "./7/ProcTHOR-Train-5095.scene_instance.json", + "./7/ProcTHOR-Train-5631.scene_instance.json", + "./7/ProcTHOR-Train-5817.scene_instance.json", + "./7/ProcTHOR-Train-5271.scene_instance.json", + "./7/ProcTHOR-Train-5630.scene_instance.json", + "./7/ProcTHOR-Train-5950.scene_instance.json", + "./7/ProcTHOR-Train-5609.scene_instance.json", + "./7/ProcTHOR-Train-5405.scene_instance.json", + "./7/ProcTHOR-Train-5898.scene_instance.json", + "./7/ProcTHOR-Train-5128.scene_instance.json", + "./7/ProcTHOR-Train-5792.scene_instance.json", + "./7/ProcTHOR-Train-5206.scene_instance.json", + "./7/ProcTHOR-Train-5597.scene_instance.json", + "./7/ProcTHOR-Train-5994.scene_instance.json", + "./7/ProcTHOR-Train-5058.scene_instance.json", + "./7/ProcTHOR-Train-5415.scene_instance.json", + "./7/ProcTHOR-Train-5143.scene_instance.json", + "./7/ProcTHOR-Train-5756.scene_instance.json", + "./7/ProcTHOR-Train-5331.scene_instance.json", + "./a/ProcTHOR-Train-8361.scene_instance.json", + "./a/ProcTHOR-Train-8648.scene_instance.json", + "./a/ProcTHOR-Train-8166.scene_instance.json", + "./a/ProcTHOR-Train-8079.scene_instance.json", + "./a/ProcTHOR-Train-8406.scene_instance.json", + "./a/ProcTHOR-Train-8653.scene_instance.json", + "./a/ProcTHOR-Train-8420.scene_instance.json", + "./a/ProcTHOR-Train-8759.scene_instance.json", + "./a/ProcTHOR-Train-8982.scene_instance.json", + "./a/ProcTHOR-Train-8886.scene_instance.json", + "./a/ProcTHOR-Train-8712.scene_instance.json", + "./a/ProcTHOR-Train-8764.scene_instance.json", + "./a/ProcTHOR-Train-8969.scene_instance.json", + "./a/ProcTHOR-Train-8941.scene_instance.json", + "./a/ProcTHOR-Train-8576.scene_instance.json", + "./a/ProcTHOR-Train-8652.scene_instance.json", + "./a/ProcTHOR-Train-8524.scene_instance.json", + "./a/ProcTHOR-Train-8132.scene_instance.json", + "./a/ProcTHOR-Train-8072.scene_instance.json", + "./a/ProcTHOR-Train-8201.scene_instance.json", + "./a/ProcTHOR-Train-8247.scene_instance.json", + "./a/ProcTHOR-Train-8519.scene_instance.json", + "./a/ProcTHOR-Train-8977.scene_instance.json", + "./a/ProcTHOR-Train-8684.scene_instance.json", + "./a/ProcTHOR-Train-8889.scene_instance.json", + "./a/ProcTHOR-Train-8240.scene_instance.json", + "./a/ProcTHOR-Train-8961.scene_instance.json", + "./a/ProcTHOR-Train-8528.scene_instance.json", + "./a/ProcTHOR-Train-8531.scene_instance.json", + "./a/ProcTHOR-Train-8540.scene_instance.json", + "./a/ProcTHOR-Train-8827.scene_instance.json", + "./a/ProcTHOR-Train-8326.scene_instance.json", + "./a/ProcTHOR-Train-8163.scene_instance.json", + "./a/ProcTHOR-Train-8430.scene_instance.json", + "./a/ProcTHOR-Train-8441.scene_instance.json", + "./a/ProcTHOR-Train-8957.scene_instance.json", + "./a/ProcTHOR-Train-8741.scene_instance.json", + "./a/ProcTHOR-Train-8730.scene_instance.json", + "./a/ProcTHOR-Train-8960.scene_instance.json", + "./a/ProcTHOR-Train-8944.scene_instance.json", + "./a/ProcTHOR-Train-8204.scene_instance.json", + "./a/ProcTHOR-Train-8896.scene_instance.json", + "./a/ProcTHOR-Train-8842.scene_instance.json", + "./a/ProcTHOR-Train-8062.scene_instance.json", + "./a/ProcTHOR-Train-8415.scene_instance.json", + "./a/ProcTHOR-Train-8876.scene_instance.json", + "./a/ProcTHOR-Train-8145.scene_instance.json", + "./a/ProcTHOR-Train-8793.scene_instance.json", + "./a/ProcTHOR-Train-8879.scene_instance.json", + "./a/ProcTHOR-Train-8584.scene_instance.json", + "./a/ProcTHOR-Train-8870.scene_instance.json", + "./a/ProcTHOR-Train-8137.scene_instance.json", + "./a/ProcTHOR-Train-8455.scene_instance.json", + "./a/ProcTHOR-Train-8833.scene_instance.json", + "./a/ProcTHOR-Train-8063.scene_instance.json", + "./a/ProcTHOR-Train-8202.scene_instance.json", + "./a/ProcTHOR-Train-8725.scene_instance.json", + "./a/ProcTHOR-Train-8118.scene_instance.json", + "./a/ProcTHOR-Train-8215.scene_instance.json", + "./a/ProcTHOR-Train-8698.scene_instance.json", + "./a/ProcTHOR-Train-8618.scene_instance.json", + "./a/ProcTHOR-Train-8284.scene_instance.json", + "./a/ProcTHOR-Train-8020.scene_instance.json", + "./a/ProcTHOR-Train-8871.scene_instance.json", + "./a/ProcTHOR-Train-8051.scene_instance.json", + "./a/ProcTHOR-Train-8344.scene_instance.json", + "./a/ProcTHOR-Train-8044.scene_instance.json", + "./a/ProcTHOR-Train-8688.scene_instance.json", + "./a/ProcTHOR-Train-8825.scene_instance.json", + "./a/ProcTHOR-Train-8536.scene_instance.json", + "./a/ProcTHOR-Train-8175.scene_instance.json", + "./a/ProcTHOR-Train-8096.scene_instance.json", + "./a/ProcTHOR-Train-8942.scene_instance.json", + "./a/ProcTHOR-Train-8998.scene_instance.json", + "./a/ProcTHOR-Train-8396.scene_instance.json", + "./a/ProcTHOR-Train-8143.scene_instance.json", + "./a/ProcTHOR-Train-8736.scene_instance.json", + "./a/ProcTHOR-Train-8188.scene_instance.json", + "./a/ProcTHOR-Train-8024.scene_instance.json", + "./a/ProcTHOR-Train-8674.scene_instance.json", + "./a/ProcTHOR-Train-8098.scene_instance.json", + "./a/ProcTHOR-Train-8251.scene_instance.json", + "./a/ProcTHOR-Train-8608.scene_instance.json", + "./a/ProcTHOR-Train-8425.scene_instance.json", + "./a/ProcTHOR-Train-8747.scene_instance.json", + "./a/ProcTHOR-Train-8050.scene_instance.json", + "./a/ProcTHOR-Train-8802.scene_instance.json", + "./a/ProcTHOR-Train-8456.scene_instance.json", + "./a/ProcTHOR-Train-8162.scene_instance.json", + "./a/ProcTHOR-Train-8159.scene_instance.json", + "./a/ProcTHOR-Train-8947.scene_instance.json", + "./a/ProcTHOR-Train-8991.scene_instance.json", + "./a/ProcTHOR-Train-8663.scene_instance.json", + "./a/ProcTHOR-Train-8667.scene_instance.json", + "./a/ProcTHOR-Train-8460.scene_instance.json", + "./a/ProcTHOR-Train-8709.scene_instance.json", + "./a/ProcTHOR-Train-8290.scene_instance.json", + "./a/ProcTHOR-Train-8169.scene_instance.json", + "./a/ProcTHOR-Train-8193.scene_instance.json", + "./a/ProcTHOR-Train-8002.scene_instance.json", + "./a/ProcTHOR-Train-8110.scene_instance.json", + "./a/ProcTHOR-Train-8865.scene_instance.json", + "./a/ProcTHOR-Train-8488.scene_instance.json", + "./a/ProcTHOR-Train-8775.scene_instance.json", + "./a/ProcTHOR-Train-8320.scene_instance.json", + "./a/ProcTHOR-Train-8556.scene_instance.json", + "./a/ProcTHOR-Train-8027.scene_instance.json", + "./a/ProcTHOR-Train-8619.scene_instance.json", + "./a/ProcTHOR-Train-8230.scene_instance.json", + "./a/ProcTHOR-Train-8139.scene_instance.json", + "./a/ProcTHOR-Train-8981.scene_instance.json", + "./a/ProcTHOR-Train-8902.scene_instance.json", + "./a/ProcTHOR-Train-8138.scene_instance.json", + "./a/ProcTHOR-Train-8372.scene_instance.json", + "./a/ProcTHOR-Train-8427.scene_instance.json", + "./a/ProcTHOR-Train-8758.scene_instance.json", + "./a/ProcTHOR-Train-8973.scene_instance.json", + "./a/ProcTHOR-Train-8965.scene_instance.json", + "./a/ProcTHOR-Train-8157.scene_instance.json", + "./a/ProcTHOR-Train-8572.scene_instance.json", + "./a/ProcTHOR-Train-8387.scene_instance.json", + "./a/ProcTHOR-Train-8378.scene_instance.json", + "./a/ProcTHOR-Train-8770.scene_instance.json", + "./a/ProcTHOR-Train-8917.scene_instance.json", + "./a/ProcTHOR-Train-8226.scene_instance.json", + "./a/ProcTHOR-Train-8603.scene_instance.json", + "./a/ProcTHOR-Train-8307.scene_instance.json", + "./a/ProcTHOR-Train-8646.scene_instance.json", + "./a/ProcTHOR-Train-8023.scene_instance.json", + "./a/ProcTHOR-Train-8845.scene_instance.json", + "./a/ProcTHOR-Train-8181.scene_instance.json", + "./a/ProcTHOR-Train-8798.scene_instance.json", + "./a/ProcTHOR-Train-8252.scene_instance.json", + "./a/ProcTHOR-Train-8853.scene_instance.json", + "./a/ProcTHOR-Train-8634.scene_instance.json", + "./a/ProcTHOR-Train-8911.scene_instance.json", + "./a/ProcTHOR-Train-8432.scene_instance.json", + "./a/ProcTHOR-Train-8824.scene_instance.json", + "./a/ProcTHOR-Train-8173.scene_instance.json", + "./a/ProcTHOR-Train-8128.scene_instance.json", + "./a/ProcTHOR-Train-8350.scene_instance.json", + "./a/ProcTHOR-Train-8183.scene_instance.json", + "./a/ProcTHOR-Train-8124.scene_instance.json", + "./a/ProcTHOR-Train-8936.scene_instance.json", + "./a/ProcTHOR-Train-8955.scene_instance.json", + "./a/ProcTHOR-Train-8563.scene_instance.json", + "./a/ProcTHOR-Train-8640.scene_instance.json", + "./a/ProcTHOR-Train-8525.scene_instance.json", + "./a/ProcTHOR-Train-8057.scene_instance.json", + "./a/ProcTHOR-Train-8241.scene_instance.json", + "./a/ProcTHOR-Train-8366.scene_instance.json", + "./a/ProcTHOR-Train-8443.scene_instance.json", + "./a/ProcTHOR-Train-8000.scene_instance.json", + "./a/ProcTHOR-Train-8994.scene_instance.json", + "./a/ProcTHOR-Train-8671.scene_instance.json", + "./a/ProcTHOR-Train-8256.scene_instance.json", + "./a/ProcTHOR-Train-8194.scene_instance.json", + "./a/ProcTHOR-Train-8974.scene_instance.json", + "./a/ProcTHOR-Train-8064.scene_instance.json", + "./a/ProcTHOR-Train-8134.scene_instance.json", + "./a/ProcTHOR-Train-8257.scene_instance.json", + "./a/ProcTHOR-Train-8863.scene_instance.json", + "./a/ProcTHOR-Train-8273.scene_instance.json", + "./a/ProcTHOR-Train-8329.scene_instance.json", + "./a/ProcTHOR-Train-8875.scene_instance.json", + "./a/ProcTHOR-Train-8877.scene_instance.json", + "./a/ProcTHOR-Train-8060.scene_instance.json", + "./a/ProcTHOR-Train-8393.scene_instance.json", + "./a/ProcTHOR-Train-8537.scene_instance.json", + "./a/ProcTHOR-Train-8645.scene_instance.json", + "./a/ProcTHOR-Train-8140.scene_instance.json", + "./a/ProcTHOR-Train-8439.scene_instance.json", + "./a/ProcTHOR-Train-8271.scene_instance.json", + "./a/ProcTHOR-Train-8074.scene_instance.json", + "./a/ProcTHOR-Train-8562.scene_instance.json", + "./a/ProcTHOR-Train-8509.scene_instance.json", + "./a/ProcTHOR-Train-8832.scene_instance.json", + "./a/ProcTHOR-Train-8334.scene_instance.json", + "./a/ProcTHOR-Train-8131.scene_instance.json", + "./a/ProcTHOR-Train-8364.scene_instance.json", + "./a/ProcTHOR-Train-8305.scene_instance.json", + "./a/ProcTHOR-Train-8597.scene_instance.json", + "./a/ProcTHOR-Train-8022.scene_instance.json", + "./a/ProcTHOR-Train-8907.scene_instance.json", + "./a/ProcTHOR-Train-8180.scene_instance.json", + "./a/ProcTHOR-Train-8224.scene_instance.json", + "./a/ProcTHOR-Train-8511.scene_instance.json", + "./a/ProcTHOR-Train-8317.scene_instance.json", + "./a/ProcTHOR-Train-8706.scene_instance.json", + "./a/ProcTHOR-Train-8383.scene_instance.json", + "./a/ProcTHOR-Train-8073.scene_instance.json", + "./a/ProcTHOR-Train-8421.scene_instance.json", + "./a/ProcTHOR-Train-8777.scene_instance.json", + "./a/ProcTHOR-Train-8768.scene_instance.json", + "./a/ProcTHOR-Train-8434.scene_instance.json", + "./a/ProcTHOR-Train-8656.scene_instance.json", + "./a/ProcTHOR-Train-8232.scene_instance.json", + "./a/ProcTHOR-Train-8932.scene_instance.json", + "./a/ProcTHOR-Train-8732.scene_instance.json", + "./a/ProcTHOR-Train-8692.scene_instance.json", + "./a/ProcTHOR-Train-8007.scene_instance.json", + "./a/ProcTHOR-Train-8905.scene_instance.json", + "./a/ProcTHOR-Train-8338.scene_instance.json", + "./a/ProcTHOR-Train-8780.scene_instance.json", + "./a/ProcTHOR-Train-8450.scene_instance.json", + "./a/ProcTHOR-Train-8375.scene_instance.json", + "./a/ProcTHOR-Train-8719.scene_instance.json", + "./a/ProcTHOR-Train-8904.scene_instance.json", + "./a/ProcTHOR-Train-8806.scene_instance.json", + "./a/ProcTHOR-Train-8151.scene_instance.json", + "./a/ProcTHOR-Train-8358.scene_instance.json", + "./a/ProcTHOR-Train-8045.scene_instance.json", + "./a/ProcTHOR-Train-8223.scene_instance.json", + "./a/ProcTHOR-Train-8752.scene_instance.json", + "./a/ProcTHOR-Train-8192.scene_instance.json", + "./a/ProcTHOR-Train-8245.scene_instance.json", + "./a/ProcTHOR-Train-8164.scene_instance.json", + "./a/ProcTHOR-Train-8272.scene_instance.json", + "./a/ProcTHOR-Train-8179.scene_instance.json", + "./a/ProcTHOR-Train-8532.scene_instance.json", + "./a/ProcTHOR-Train-8783.scene_instance.json", + "./a/ProcTHOR-Train-8056.scene_instance.json", + "./a/ProcTHOR-Train-8323.scene_instance.json", + "./a/ProcTHOR-Train-8755.scene_instance.json", + "./a/ProcTHOR-Train-8622.scene_instance.json", + "./a/ProcTHOR-Train-8324.scene_instance.json", + "./a/ProcTHOR-Train-8594.scene_instance.json", + "./a/ProcTHOR-Train-8891.scene_instance.json", + "./a/ProcTHOR-Train-8606.scene_instance.json", + "./a/ProcTHOR-Train-8882.scene_instance.json", + "./a/ProcTHOR-Train-8222.scene_instance.json", + "./a/ProcTHOR-Train-8538.scene_instance.json", + "./a/ProcTHOR-Train-8996.scene_instance.json", + "./a/ProcTHOR-Train-8967.scene_instance.json", + "./a/ProcTHOR-Train-8122.scene_instance.json", + "./a/ProcTHOR-Train-8623.scene_instance.json", + "./a/ProcTHOR-Train-8227.scene_instance.json", + "./a/ProcTHOR-Train-8778.scene_instance.json", + "./a/ProcTHOR-Train-8210.scene_instance.json", + "./a/ProcTHOR-Train-8389.scene_instance.json", + "./a/ProcTHOR-Train-8209.scene_instance.json", + "./a/ProcTHOR-Train-8214.scene_instance.json", + "./a/ProcTHOR-Train-8604.scene_instance.json", + "./a/ProcTHOR-Train-8723.scene_instance.json", + "./a/ProcTHOR-Train-8880.scene_instance.json", + "./a/ProcTHOR-Train-8810.scene_instance.json", + "./a/ProcTHOR-Train-8611.scene_instance.json", + "./a/ProcTHOR-Train-8900.scene_instance.json", + "./a/ProcTHOR-Train-8269.scene_instance.json", + "./a/ProcTHOR-Train-8579.scene_instance.json", + "./a/ProcTHOR-Train-8922.scene_instance.json", + "./a/ProcTHOR-Train-8647.scene_instance.json", + "./a/ProcTHOR-Train-8196.scene_instance.json", + "./a/ProcTHOR-Train-8090.scene_instance.json", + "./a/ProcTHOR-Train-8828.scene_instance.json", + "./a/ProcTHOR-Train-8410.scene_instance.json", + "./a/ProcTHOR-Train-8407.scene_instance.json", + "./a/ProcTHOR-Train-8742.scene_instance.json", + "./a/ProcTHOR-Train-8746.scene_instance.json", + "./a/ProcTHOR-Train-8010.scene_instance.json", + "./a/ProcTHOR-Train-8785.scene_instance.json", + "./a/ProcTHOR-Train-8184.scene_instance.json", + "./a/ProcTHOR-Train-8384.scene_instance.json", + "./a/ProcTHOR-Train-8745.scene_instance.json", + "./a/ProcTHOR-Train-8866.scene_instance.json", + "./a/ProcTHOR-Train-8112.scene_instance.json", + "./a/ProcTHOR-Train-8014.scene_instance.json", + "./a/ProcTHOR-Train-8704.scene_instance.json", + "./a/ProcTHOR-Train-8262.scene_instance.json", + "./a/ProcTHOR-Train-8392.scene_instance.json", + "./a/ProcTHOR-Train-8642.scene_instance.json", + "./a/ProcTHOR-Train-8566.scene_instance.json", + "./a/ProcTHOR-Train-8318.scene_instance.json", + "./a/ProcTHOR-Train-8954.scene_instance.json", + "./a/ProcTHOR-Train-8970.scene_instance.json", + "./a/ProcTHOR-Train-8076.scene_instance.json", + "./a/ProcTHOR-Train-8949.scene_instance.json", + "./a/ProcTHOR-Train-8228.scene_instance.json", + "./a/ProcTHOR-Train-8826.scene_instance.json", + "./a/ProcTHOR-Train-8070.scene_instance.json", + "./a/ProcTHOR-Train-8113.scene_instance.json", + "./a/ProcTHOR-Train-8170.scene_instance.json", + "./a/ProcTHOR-Train-8727.scene_instance.json", + "./a/ProcTHOR-Train-8486.scene_instance.json", + "./a/ProcTHOR-Train-8718.scene_instance.json", + "./a/ProcTHOR-Train-8221.scene_instance.json", + "./a/ProcTHOR-Train-8897.scene_instance.json", + "./a/ProcTHOR-Train-8147.scene_instance.json", + "./a/ProcTHOR-Train-8043.scene_instance.json", + "./a/ProcTHOR-Train-8412.scene_instance.json", + "./a/ProcTHOR-Train-8006.scene_instance.json", + "./a/ProcTHOR-Train-8779.scene_instance.json", + "./a/ProcTHOR-Train-8750.scene_instance.json", + "./a/ProcTHOR-Train-8795.scene_instance.json", + "./a/ProcTHOR-Train-8694.scene_instance.json", + "./a/ProcTHOR-Train-8444.scene_instance.json", + "./a/ProcTHOR-Train-8846.scene_instance.json", + "./a/ProcTHOR-Train-8345.scene_instance.json", + "./a/ProcTHOR-Train-8729.scene_instance.json", + "./a/ProcTHOR-Train-8148.scene_instance.json", + "./a/ProcTHOR-Train-8963.scene_instance.json", + "./a/ProcTHOR-Train-8276.scene_instance.json", + "./a/ProcTHOR-Train-8570.scene_instance.json", + "./a/ProcTHOR-Train-8028.scene_instance.json", + "./a/ProcTHOR-Train-8280.scene_instance.json", + "./a/ProcTHOR-Train-8860.scene_instance.json", + "./a/ProcTHOR-Train-8915.scene_instance.json", + "./a/ProcTHOR-Train-8734.scene_instance.json", + "./a/ProcTHOR-Train-8569.scene_instance.json", + "./a/ProcTHOR-Train-8781.scene_instance.json", + "./a/ProcTHOR-Train-8610.scene_instance.json", + "./a/ProcTHOR-Train-8839.scene_instance.json", + "./a/ProcTHOR-Train-8564.scene_instance.json", + "./a/ProcTHOR-Train-8728.scene_instance.json", + "./a/ProcTHOR-Train-8635.scene_instance.json", + "./a/ProcTHOR-Train-8452.scene_instance.json", + "./a/ProcTHOR-Train-8605.scene_instance.json", + "./a/ProcTHOR-Train-8995.scene_instance.json", + "./a/ProcTHOR-Train-8686.scene_instance.json", + "./a/ProcTHOR-Train-8391.scene_instance.json", + "./a/ProcTHOR-Train-8433.scene_instance.json", + "./a/ProcTHOR-Train-8691.scene_instance.json", + "./a/ProcTHOR-Train-8715.scene_instance.json", + "./a/ProcTHOR-Train-8254.scene_instance.json", + "./a/ProcTHOR-Train-8258.scene_instance.json", + "./a/ProcTHOR-Train-8483.scene_instance.json", + "./a/ProcTHOR-Train-8390.scene_instance.json", + "./a/ProcTHOR-Train-8466.scene_instance.json", + "./a/ProcTHOR-Train-8933.scene_instance.json", + "./a/ProcTHOR-Train-8599.scene_instance.json", + "./a/ProcTHOR-Train-8830.scene_instance.json", + "./a/ProcTHOR-Train-8030.scene_instance.json", + "./a/ProcTHOR-Train-8988.scene_instance.json", + "./a/ProcTHOR-Train-8086.scene_instance.json", + "./a/ProcTHOR-Train-8349.scene_instance.json", + "./a/ProcTHOR-Train-8638.scene_instance.json", + "./a/ProcTHOR-Train-8521.scene_instance.json", + "./a/ProcTHOR-Train-8207.scene_instance.json", + "./a/ProcTHOR-Train-8054.scene_instance.json", + "./a/ProcTHOR-Train-8561.scene_instance.json", + "./a/ProcTHOR-Train-8306.scene_instance.json", + "./a/ProcTHOR-Train-8948.scene_instance.json", + "./a/ProcTHOR-Train-8107.scene_instance.json", + "./a/ProcTHOR-Train-8327.scene_instance.json", + "./a/ProcTHOR-Train-8545.scene_instance.json", + "./a/ProcTHOR-Train-8884.scene_instance.json", + "./a/ProcTHOR-Train-8376.scene_instance.json", + "./a/ProcTHOR-Train-8304.scene_instance.json", + "./a/ProcTHOR-Train-8102.scene_instance.json", + "./a/ProcTHOR-Train-8186.scene_instance.json", + "./a/ProcTHOR-Train-8796.scene_instance.json", + "./a/ProcTHOR-Train-8820.scene_instance.json", + "./a/ProcTHOR-Train-8721.scene_instance.json", + "./a/ProcTHOR-Train-8693.scene_instance.json", + "./a/ProcTHOR-Train-8264.scene_instance.json", + "./a/ProcTHOR-Train-8813.scene_instance.json", + "./a/ProcTHOR-Train-8339.scene_instance.json", + "./a/ProcTHOR-Train-8568.scene_instance.json", + "./a/ProcTHOR-Train-8506.scene_instance.json", + "./a/ProcTHOR-Train-8078.scene_instance.json", + "./a/ProcTHOR-Train-8152.scene_instance.json", + "./a/ProcTHOR-Train-8655.scene_instance.json", + "./a/ProcTHOR-Train-8125.scene_instance.json", + "./a/ProcTHOR-Train-8155.scene_instance.json", + "./a/ProcTHOR-Train-8492.scene_instance.json", + "./a/ProcTHOR-Train-8347.scene_instance.json", + "./a/ProcTHOR-Train-8449.scene_instance.json", + "./a/ProcTHOR-Train-8394.scene_instance.json", + "./a/ProcTHOR-Train-8539.scene_instance.json", + "./a/ProcTHOR-Train-8748.scene_instance.json", + "./a/ProcTHOR-Train-8776.scene_instance.json", + "./a/ProcTHOR-Train-8953.scene_instance.json", + "./a/ProcTHOR-Train-8371.scene_instance.json", + "./a/ProcTHOR-Train-8649.scene_instance.json", + "./a/ProcTHOR-Train-8083.scene_instance.json", + "./a/ProcTHOR-Train-8894.scene_instance.json", + "./a/ProcTHOR-Train-8046.scene_instance.json", + "./a/ProcTHOR-Train-8217.scene_instance.json", + "./a/ProcTHOR-Train-8789.scene_instance.json", + "./a/ProcTHOR-Train-8208.scene_instance.json", + "./a/ProcTHOR-Train-8784.scene_instance.json", + "./a/ProcTHOR-Train-8328.scene_instance.json", + "./a/ProcTHOR-Train-8666.scene_instance.json", + "./a/ProcTHOR-Train-8836.scene_instance.json", + "./a/ProcTHOR-Train-8419.scene_instance.json", + "./a/ProcTHOR-Train-8626.scene_instance.json", + "./a/ProcTHOR-Train-8330.scene_instance.json", + "./a/ProcTHOR-Train-8459.scene_instance.json", + "./a/ProcTHOR-Train-8901.scene_instance.json", + "./a/ProcTHOR-Train-8529.scene_instance.json", + "./a/ProcTHOR-Train-8337.scene_instance.json", + "./a/ProcTHOR-Train-8080.scene_instance.json", + "./a/ProcTHOR-Train-8921.scene_instance.json", + "./a/ProcTHOR-Train-8617.scene_instance.json", + "./a/ProcTHOR-Train-8115.scene_instance.json", + "./a/ProcTHOR-Train-8231.scene_instance.json", + "./a/ProcTHOR-Train-8341.scene_instance.json", + "./a/ProcTHOR-Train-8351.scene_instance.json", + "./a/ProcTHOR-Train-8172.scene_instance.json", + "./a/ProcTHOR-Train-8491.scene_instance.json", + "./a/ProcTHOR-Train-8708.scene_instance.json", + "./a/ProcTHOR-Train-8673.scene_instance.json", + "./a/ProcTHOR-Train-8092.scene_instance.json", + "./a/ProcTHOR-Train-8294.scene_instance.json", + "./a/ProcTHOR-Train-8331.scene_instance.json", + "./a/ProcTHOR-Train-8696.scene_instance.json", + "./a/ProcTHOR-Train-8094.scene_instance.json", + "./a/ProcTHOR-Train-8400.scene_instance.json", + "./a/ProcTHOR-Train-8435.scene_instance.json", + "./a/ProcTHOR-Train-8864.scene_instance.json", + "./a/ProcTHOR-Train-8744.scene_instance.json", + "./a/ProcTHOR-Train-8821.scene_instance.json", + "./a/ProcTHOR-Train-8431.scene_instance.json", + "./a/ProcTHOR-Train-8312.scene_instance.json", + "./a/ProcTHOR-Train-8448.scene_instance.json", + "./a/ProcTHOR-Train-8325.scene_instance.json", + "./a/ProcTHOR-Train-8543.scene_instance.json", + "./a/ProcTHOR-Train-8475.scene_instance.json", + "./a/ProcTHOR-Train-8614.scene_instance.json", + "./a/ProcTHOR-Train-8462.scene_instance.json", + "./a/ProcTHOR-Train-8414.scene_instance.json", + "./a/ProcTHOR-Train-8238.scene_instance.json", + "./a/ProcTHOR-Train-8135.scene_instance.json", + "./a/ProcTHOR-Train-8799.scene_instance.json", + "./a/ProcTHOR-Train-8754.scene_instance.json", + "./a/ProcTHOR-Train-8722.scene_instance.json", + "./a/ProcTHOR-Train-8971.scene_instance.json", + "./a/ProcTHOR-Train-8049.scene_instance.json", + "./a/ProcTHOR-Train-8388.scene_instance.json", + "./a/ProcTHOR-Train-8365.scene_instance.json", + "./a/ProcTHOR-Train-8530.scene_instance.json", + "./a/ProcTHOR-Train-8235.scene_instance.json", + "./a/ProcTHOR-Train-8093.scene_instance.json", + "./a/ProcTHOR-Train-8220.scene_instance.json", + "./a/ProcTHOR-Train-8416.scene_instance.json", + "./a/ProcTHOR-Train-8658.scene_instance.json", + "./a/ProcTHOR-Train-8205.scene_instance.json", + "./a/ProcTHOR-Train-8801.scene_instance.json", + "./a/ProcTHOR-Train-8493.scene_instance.json", + "./a/ProcTHOR-Train-8895.scene_instance.json", + "./a/ProcTHOR-Train-8296.scene_instance.json", + "./a/ProcTHOR-Train-8934.scene_instance.json", + "./a/ProcTHOR-Train-8031.scene_instance.json", + "./a/ProcTHOR-Train-8095.scene_instance.json", + "./a/ProcTHOR-Train-8353.scene_instance.json", + "./a/ProcTHOR-Train-8017.scene_instance.json", + "./a/ProcTHOR-Train-8052.scene_instance.json", + "./a/ProcTHOR-Train-8800.scene_instance.json", + "./a/ProcTHOR-Train-8675.scene_instance.json", + "./a/ProcTHOR-Train-8761.scene_instance.json", + "./a/ProcTHOR-Train-8363.scene_instance.json", + "./a/ProcTHOR-Train-8356.scene_instance.json", + "./a/ProcTHOR-Train-8075.scene_instance.json", + "./a/ProcTHOR-Train-8478.scene_instance.json", + "./a/ProcTHOR-Train-8299.scene_instance.json", + "./a/ProcTHOR-Train-8034.scene_instance.json", + "./a/ProcTHOR-Train-8661.scene_instance.json", + "./a/ProcTHOR-Train-8374.scene_instance.json", + "./a/ProcTHOR-Train-8505.scene_instance.json", + "./a/ProcTHOR-Train-8630.scene_instance.json", + "./a/ProcTHOR-Train-8236.scene_instance.json", + "./a/ProcTHOR-Train-8762.scene_instance.json", + "./a/ProcTHOR-Train-8490.scene_instance.json", + "./a/ProcTHOR-Train-8225.scene_instance.json", + "./a/ProcTHOR-Train-8481.scene_instance.json", + "./a/ProcTHOR-Train-8315.scene_instance.json", + "./a/ProcTHOR-Train-8367.scene_instance.json", + "./a/ProcTHOR-Train-8041.scene_instance.json", + "./a/ProcTHOR-Train-8739.scene_instance.json", + "./a/ProcTHOR-Train-8910.scene_instance.json", + "./a/ProcTHOR-Train-8772.scene_instance.json", + "./a/ProcTHOR-Train-8177.scene_instance.json", + "./a/ProcTHOR-Train-8665.scene_instance.json", + "./a/ProcTHOR-Train-8654.scene_instance.json", + "./a/ProcTHOR-Train-8928.scene_instance.json", + "./a/ProcTHOR-Train-8508.scene_instance.json", + "./a/ProcTHOR-Train-8336.scene_instance.json", + "./a/ProcTHOR-Train-8544.scene_instance.json", + "./a/ProcTHOR-Train-8553.scene_instance.json", + "./a/ProcTHOR-Train-8952.scene_instance.json", + "./a/ProcTHOR-Train-8106.scene_instance.json", + "./a/ProcTHOR-Train-8141.scene_instance.json", + "./a/ProcTHOR-Train-8641.scene_instance.json", + "./a/ProcTHOR-Train-8292.scene_instance.json", + "./a/ProcTHOR-Train-8644.scene_instance.json", + "./a/ProcTHOR-Train-8788.scene_instance.json", + "./a/ProcTHOR-Train-8887.scene_instance.json", + "./a/ProcTHOR-Train-8578.scene_instance.json", + "./a/ProcTHOR-Train-8681.scene_instance.json", + "./a/ProcTHOR-Train-8807.scene_instance.json", + "./a/ProcTHOR-Train-8154.scene_instance.json", + "./a/ProcTHOR-Train-8873.scene_instance.json", + "./a/ProcTHOR-Train-8700.scene_instance.json", + "./a/ProcTHOR-Train-8401.scene_instance.json", + "./a/ProcTHOR-Train-8713.scene_instance.json", + "./a/ProcTHOR-Train-8565.scene_instance.json", + "./a/ProcTHOR-Train-8355.scene_instance.json", + "./a/ProcTHOR-Train-8126.scene_instance.json", + "./a/ProcTHOR-Train-8753.scene_instance.json", + "./a/ProcTHOR-Train-8849.scene_instance.json", + "./a/ProcTHOR-Train-8149.scene_instance.json", + "./a/ProcTHOR-Train-8068.scene_instance.json", + "./a/ProcTHOR-Train-8442.scene_instance.json", + "./a/ProcTHOR-Train-8743.scene_instance.json", + "./a/ProcTHOR-Train-8160.scene_instance.json", + "./a/ProcTHOR-Train-8510.scene_instance.json", + "./a/ProcTHOR-Train-8108.scene_instance.json", + "./a/ProcTHOR-Train-8676.scene_instance.json", + "./a/ProcTHOR-Train-8680.scene_instance.json", + "./a/ProcTHOR-Train-8477.scene_instance.json", + "./a/ProcTHOR-Train-8370.scene_instance.json", + "./a/ProcTHOR-Train-8867.scene_instance.json", + "./a/ProcTHOR-Train-8316.scene_instance.json", + "./a/ProcTHOR-Train-8405.scene_instance.json", + "./a/ProcTHOR-Train-8479.scene_instance.json", + "./a/ProcTHOR-Train-8956.scene_instance.json", + "./a/ProcTHOR-Train-8596.scene_instance.json", + "./a/ProcTHOR-Train-8527.scene_instance.json", + "./a/ProcTHOR-Train-8474.scene_instance.json", + "./a/ProcTHOR-Train-8920.scene_instance.json", + "./a/ProcTHOR-Train-8541.scene_instance.json", + "./a/ProcTHOR-Train-8377.scene_instance.json", + "./a/ProcTHOR-Train-8650.scene_instance.json", + "./a/ProcTHOR-Train-8077.scene_instance.json", + "./a/ProcTHOR-Train-8918.scene_instance.json", + "./a/ProcTHOR-Train-8200.scene_instance.json", + "./a/ProcTHOR-Train-8413.scene_instance.json", + "./a/ProcTHOR-Train-8055.scene_instance.json", + "./a/ProcTHOR-Train-8627.scene_instance.json", + "./a/ProcTHOR-Train-8176.scene_instance.json", + "./a/ProcTHOR-Train-8575.scene_instance.json", + "./a/ProcTHOR-Train-8497.scene_instance.json", + "./a/ProcTHOR-Train-8494.scene_instance.json", + "./a/ProcTHOR-Train-8417.scene_instance.json", + "./a/ProcTHOR-Train-8767.scene_instance.json", + "./a/ProcTHOR-Train-8234.scene_instance.json", + "./a/ProcTHOR-Train-8302.scene_instance.json", + "./a/ProcTHOR-Train-8672.scene_instance.json", + "./a/ProcTHOR-Train-8670.scene_instance.json", + "./a/ProcTHOR-Train-8343.scene_instance.json", + "./a/ProcTHOR-Train-8607.scene_instance.json", + "./a/ProcTHOR-Train-8916.scene_instance.json", + "./a/ProcTHOR-Train-8104.scene_instance.json", + "./a/ProcTHOR-Train-8011.scene_instance.json", + "./a/ProcTHOR-Train-8248.scene_instance.json", + "./a/ProcTHOR-Train-8197.scene_instance.json", + "./a/ProcTHOR-Train-8517.scene_instance.json", + "./a/ProcTHOR-Train-8711.scene_instance.json", + "./a/ProcTHOR-Train-8620.scene_instance.json", + "./a/ProcTHOR-Train-8457.scene_instance.json", + "./a/ProcTHOR-Train-8837.scene_instance.json", + "./a/ProcTHOR-Train-8265.scene_instance.json", + "./a/ProcTHOR-Train-8470.scene_instance.json", + "./a/ProcTHOR-Train-8463.scene_instance.json", + "./a/ProcTHOR-Train-8679.scene_instance.json", + "./a/ProcTHOR-Train-8281.scene_instance.json", + "./a/ProcTHOR-Train-8883.scene_instance.json", + "./a/ProcTHOR-Train-8856.scene_instance.json", + "./a/ProcTHOR-Train-8411.scene_instance.json", + "./a/ProcTHOR-Train-8819.scene_instance.json", + "./a/ProcTHOR-Train-8275.scene_instance.json", + "./a/ProcTHOR-Train-8803.scene_instance.json", + "./a/ProcTHOR-Train-8972.scene_instance.json", + "./a/ProcTHOR-Train-8261.scene_instance.json", + "./a/ProcTHOR-Train-8717.scene_instance.json", + "./a/ProcTHOR-Train-8249.scene_instance.json", + "./a/ProcTHOR-Train-8872.scene_instance.json", + "./a/ProcTHOR-Train-8158.scene_instance.json", + "./a/ProcTHOR-Train-8805.scene_instance.json", + "./a/ProcTHOR-Train-8348.scene_instance.json", + "./a/ProcTHOR-Train-8297.scene_instance.json", + "./a/ProcTHOR-Train-8552.scene_instance.json", + "./a/ProcTHOR-Train-8424.scene_instance.json", + "./a/ProcTHOR-Train-8291.scene_instance.json", + "./a/ProcTHOR-Train-8829.scene_instance.json", + "./a/ProcTHOR-Train-8682.scene_instance.json", + "./a/ProcTHOR-Train-8458.scene_instance.json", + "./a/ProcTHOR-Train-8612.scene_instance.json", + "./a/ProcTHOR-Train-8182.scene_instance.json", + "./a/ProcTHOR-Train-8303.scene_instance.json", + "./a/ProcTHOR-Train-8243.scene_instance.json", + "./a/ProcTHOR-Train-8838.scene_instance.json", + "./a/ProcTHOR-Train-8012.scene_instance.json", + "./a/ProcTHOR-Train-8036.scene_instance.json", + "./a/ProcTHOR-Train-8890.scene_instance.json", + "./a/ProcTHOR-Train-8592.scene_instance.json", + "./a/ProcTHOR-Train-8520.scene_instance.json", + "./a/ProcTHOR-Train-8958.scene_instance.json", + "./a/ProcTHOR-Train-8861.scene_instance.json", + "./a/ProcTHOR-Train-8542.scene_instance.json", + "./a/ProcTHOR-Train-8398.scene_instance.json", + "./a/ProcTHOR-Train-8453.scene_instance.json", + "./a/ProcTHOR-Train-8976.scene_instance.json", + "./a/ProcTHOR-Train-8171.scene_instance.json", + "./a/ProcTHOR-Train-8986.scene_instance.json", + "./a/ProcTHOR-Train-8447.scene_instance.json", + "./a/ProcTHOR-Train-8178.scene_instance.json", + "./a/ProcTHOR-Train-8233.scene_instance.json", + "./a/ProcTHOR-Train-8332.scene_instance.json", + "./a/ProcTHOR-Train-8213.scene_instance.json", + "./a/ProcTHOR-Train-8808.scene_instance.json", + "./a/ProcTHOR-Train-8342.scene_instance.json", + "./a/ProcTHOR-Train-8004.scene_instance.json", + "./a/ProcTHOR-Train-8968.scene_instance.json", + "./a/ProcTHOR-Train-8295.scene_instance.json", + "./a/ProcTHOR-Train-8927.scene_instance.json", + "./a/ProcTHOR-Train-8850.scene_instance.json", + "./a/ProcTHOR-Train-8771.scene_instance.json", + "./a/ProcTHOR-Train-8516.scene_instance.json", + "./a/ProcTHOR-Train-8989.scene_instance.json", + "./a/ProcTHOR-Train-8636.scene_instance.json", + "./a/ProcTHOR-Train-8512.scene_instance.json", + "./a/ProcTHOR-Train-8906.scene_instance.json", + "./a/ProcTHOR-Train-8878.scene_instance.json", + "./a/ProcTHOR-Train-8035.scene_instance.json", + "./a/ProcTHOR-Train-8146.scene_instance.json", + "./a/ProcTHOR-Train-8156.scene_instance.json", + "./a/ProcTHOR-Train-8938.scene_instance.json", + "./a/ProcTHOR-Train-8144.scene_instance.json", + "./a/ProcTHOR-Train-8314.scene_instance.json", + "./a/ProcTHOR-Train-8114.scene_instance.json", + "./a/ProcTHOR-Train-8874.scene_instance.json", + "./a/ProcTHOR-Train-8848.scene_instance.json", + "./a/ProcTHOR-Train-8999.scene_instance.json", + "./a/ProcTHOR-Train-8362.scene_instance.json", + "./a/ProcTHOR-Train-8786.scene_instance.json", + "./a/ProcTHOR-Train-8084.scene_instance.json", + "./a/ProcTHOR-Train-8185.scene_instance.json", + "./a/ProcTHOR-Train-8487.scene_instance.json", + "./a/ProcTHOR-Train-8737.scene_instance.json", + "./a/ProcTHOR-Train-8814.scene_instance.json", + "./a/ProcTHOR-Train-8909.scene_instance.json", + "./a/ProcTHOR-Train-8100.scene_instance.json", + "./a/ProcTHOR-Train-8436.scene_instance.json", + "./a/ProcTHOR-Train-8191.scene_instance.json", + "./a/ProcTHOR-Train-8548.scene_instance.json", + "./a/ProcTHOR-Train-8489.scene_instance.json", + "./a/ProcTHOR-Train-8501.scene_instance.json", + "./a/ProcTHOR-Train-8551.scene_instance.json", + "./a/ProcTHOR-Train-8574.scene_instance.json", + "./a/ProcTHOR-Train-8782.scene_instance.json", + "./a/ProcTHOR-Train-8992.scene_instance.json", + "./a/ProcTHOR-Train-8101.scene_instance.json", + "./a/ProcTHOR-Train-8212.scene_instance.json", + "./a/ProcTHOR-Train-8945.scene_instance.json", + "./a/ProcTHOR-Train-8765.scene_instance.json", + "./a/ProcTHOR-Train-8733.scene_instance.json", + "./a/ProcTHOR-Train-8724.scene_instance.json", + "./a/ProcTHOR-Train-8631.scene_instance.json", + "./a/ProcTHOR-Train-8282.scene_instance.json", + "./a/ProcTHOR-Train-8518.scene_instance.json", + "./a/ProcTHOR-Train-8804.scene_instance.json", + "./a/ProcTHOR-Train-8993.scene_instance.json", + "./a/ProcTHOR-Train-8812.scene_instance.json", + "./a/ProcTHOR-Train-8690.scene_instance.json", + "./a/ProcTHOR-Train-8923.scene_instance.json", + "./a/ProcTHOR-Train-8003.scene_instance.json", + "./a/ProcTHOR-Train-8749.scene_instance.json", + "./a/ProcTHOR-Train-8892.scene_instance.json", + "./a/ProcTHOR-Train-8586.scene_instance.json", + "./a/ProcTHOR-Train-8975.scene_instance.json", + "./a/ProcTHOR-Train-8609.scene_instance.json", + "./a/ProcTHOR-Train-8651.scene_instance.json", + "./a/ProcTHOR-Train-8513.scene_instance.json", + "./a/ProcTHOR-Train-8931.scene_instance.json", + "./a/ProcTHOR-Train-8105.scene_instance.json", + "./a/ProcTHOR-Train-8168.scene_instance.json", + "./a/ProcTHOR-Train-8440.scene_instance.json", + "./a/ProcTHOR-Train-8038.scene_instance.json", + "./a/ProcTHOR-Train-8482.scene_instance.json", + "./a/ProcTHOR-Train-8885.scene_instance.json", + "./a/ProcTHOR-Train-8533.scene_instance.json", + "./a/ProcTHOR-Train-8912.scene_instance.json", + "./a/ProcTHOR-Train-8032.scene_instance.json", + "./a/ProcTHOR-Train-8109.scene_instance.json", + "./a/ProcTHOR-Train-8161.scene_instance.json", + "./a/ProcTHOR-Train-8997.scene_instance.json", + "./a/ProcTHOR-Train-8557.scene_instance.json", + "./a/ProcTHOR-Train-8381.scene_instance.json", + "./a/ProcTHOR-Train-8267.scene_instance.json", + "./a/ProcTHOR-Train-8616.scene_instance.json", + "./a/ProcTHOR-Train-8081.scene_instance.json", + "./a/ProcTHOR-Train-8990.scene_instance.json", + "./a/ProcTHOR-Train-8943.scene_instance.json", + "./a/ProcTHOR-Train-8263.scene_instance.json", + "./a/ProcTHOR-Train-8683.scene_instance.json", + "./a/ProcTHOR-Train-8237.scene_instance.json", + "./a/ProcTHOR-Train-8593.scene_instance.json", + "./a/ProcTHOR-Train-8422.scene_instance.json", + "./a/ProcTHOR-Train-8504.scene_instance.json", + "./a/ProcTHOR-Train-8266.scene_instance.json", + "./a/ProcTHOR-Train-8852.scene_instance.json", + "./a/ProcTHOR-Train-8740.scene_instance.json", + "./a/ProcTHOR-Train-8167.scene_instance.json", + "./a/ProcTHOR-Train-8588.scene_instance.json", + "./a/ProcTHOR-Train-8219.scene_instance.json", + "./a/ProcTHOR-Train-8582.scene_instance.json", + "./a/ProcTHOR-Train-8792.scene_instance.json", + "./a/ProcTHOR-Train-8503.scene_instance.json", + "./a/ProcTHOR-Train-8851.scene_instance.json", + "./a/ProcTHOR-Train-8008.scene_instance.json", + "./a/ProcTHOR-Train-8946.scene_instance.json", + "./a/ProcTHOR-Train-8855.scene_instance.json", + "./a/ProcTHOR-Train-8469.scene_instance.json", + "./a/ProcTHOR-Train-8980.scene_instance.json", + "./a/ProcTHOR-Train-8279.scene_instance.json", + "./a/ProcTHOR-Train-8625.scene_instance.json", + "./a/ProcTHOR-Train-8333.scene_instance.json", + "./a/ProcTHOR-Train-8515.scene_instance.json", + "./a/ProcTHOR-Train-8009.scene_instance.json", + "./a/ProcTHOR-Train-8190.scene_instance.json", + "./a/ProcTHOR-Train-8465.scene_instance.json", + "./a/ProcTHOR-Train-8300.scene_instance.json", + "./a/ProcTHOR-Train-8373.scene_instance.json", + "./a/ProcTHOR-Train-8285.scene_instance.json", + "./a/ProcTHOR-Train-8260.scene_instance.json", + "./a/ProcTHOR-Train-8731.scene_instance.json", + "./a/ProcTHOR-Train-8123.scene_instance.json", + "./a/ProcTHOR-Train-8662.scene_instance.json", + "./a/ProcTHOR-Train-8198.scene_instance.json", + "./a/ProcTHOR-Train-8495.scene_instance.json", + "./a/ProcTHOR-Train-8018.scene_instance.json", + "./a/ProcTHOR-Train-8053.scene_instance.json", + "./a/ProcTHOR-Train-8091.scene_instance.json", + "./a/ProcTHOR-Train-8847.scene_instance.json", + "./a/ProcTHOR-Train-8082.scene_instance.json", + "./a/ProcTHOR-Train-8423.scene_instance.json", + "./a/ProcTHOR-Train-8464.scene_instance.json", + "./a/ProcTHOR-Train-8738.scene_instance.json", + "./a/ProcTHOR-Train-8088.scene_instance.json", + "./a/ProcTHOR-Train-8844.scene_instance.json", + "./a/ProcTHOR-Train-8308.scene_instance.json", + "./a/ProcTHOR-Train-8888.scene_instance.json", + "./a/ProcTHOR-Train-8559.scene_instance.json", + "./a/ProcTHOR-Train-8818.scene_instance.json", + "./a/ProcTHOR-Train-8087.scene_instance.json", + "./a/ProcTHOR-Train-8001.scene_instance.json", + "./a/ProcTHOR-Train-8408.scene_instance.json", + "./a/ProcTHOR-Train-8380.scene_instance.json", + "./a/ProcTHOR-Train-8523.scene_instance.json", + "./a/ProcTHOR-Train-8577.scene_instance.json", + "./a/ProcTHOR-Train-8357.scene_instance.json", + "./a/ProcTHOR-Train-8677.scene_instance.json", + "./a/ProcTHOR-Train-8705.scene_instance.json", + "./a/ProcTHOR-Train-8026.scene_instance.json", + "./a/ProcTHOR-Train-8668.scene_instance.json", + "./a/ProcTHOR-Train-8966.scene_instance.json", + "./a/ProcTHOR-Train-8854.scene_instance.json", + "./a/ProcTHOR-Train-8278.scene_instance.json", + "./a/ProcTHOR-Train-8817.scene_instance.json", + "./a/ProcTHOR-Train-8959.scene_instance.json", + "./a/ProcTHOR-Train-8033.scene_instance.json", + "./a/ProcTHOR-Train-8919.scene_instance.json", + "./a/ProcTHOR-Train-8120.scene_instance.json", + "./a/ProcTHOR-Train-8369.scene_instance.json", + "./a/ProcTHOR-Train-8404.scene_instance.json", + "./a/ProcTHOR-Train-8311.scene_instance.json", + "./a/ProcTHOR-Train-8899.scene_instance.json", + "./a/ProcTHOR-Train-8558.scene_instance.json", + "./a/ProcTHOR-Train-8964.scene_instance.json", + "./a/ProcTHOR-Train-8624.scene_instance.json", + "./a/ProcTHOR-Train-8903.scene_instance.json", + "./a/ProcTHOR-Train-8773.scene_instance.json", + "./a/ProcTHOR-Train-8868.scene_instance.json", + "./a/ProcTHOR-Train-8522.scene_instance.json", + "./a/ProcTHOR-Train-8657.scene_instance.json", + "./a/ProcTHOR-Train-8787.scene_instance.json", + "./a/ProcTHOR-Train-8471.scene_instance.json", + "./a/ProcTHOR-Train-8571.scene_instance.json", + "./a/ProcTHOR-Train-8426.scene_instance.json", + "./a/ProcTHOR-Train-8794.scene_instance.json", + "./a/ProcTHOR-Train-8498.scene_instance.json", + "./a/ProcTHOR-Train-8589.scene_instance.json", + "./a/ProcTHOR-Train-8669.scene_instance.json", + "./a/ProcTHOR-Train-8037.scene_instance.json", + "./a/ProcTHOR-Train-8418.scene_instance.json", + "./a/ProcTHOR-Train-8930.scene_instance.json", + "./a/ProcTHOR-Train-8583.scene_instance.json", + "./a/ProcTHOR-Train-8859.scene_instance.json", + "./a/ProcTHOR-Train-8119.scene_instance.json", + "./a/ProcTHOR-Train-8121.scene_instance.json", + "./a/ProcTHOR-Train-8514.scene_instance.json", + "./a/ProcTHOR-Train-8244.scene_instance.json", + "./a/ProcTHOR-Train-8025.scene_instance.json", + "./a/ProcTHOR-Train-8590.scene_instance.json", + "./a/ProcTHOR-Train-8701.scene_instance.json", + "./a/ProcTHOR-Train-8893.scene_instance.json", + "./a/ProcTHOR-Train-8206.scene_instance.json", + "./a/ProcTHOR-Train-8822.scene_instance.json", + "./a/ProcTHOR-Train-8467.scene_instance.json", + "./a/ProcTHOR-Train-8468.scene_instance.json", + "./a/ProcTHOR-Train-8352.scene_instance.json", + "./a/ProcTHOR-Train-8019.scene_instance.json", + "./a/ProcTHOR-Train-8402.scene_instance.json", + "./a/ProcTHOR-Train-8628.scene_instance.json", + "./a/ProcTHOR-Train-8507.scene_instance.json", + "./a/ProcTHOR-Train-8438.scene_instance.json", + "./a/ProcTHOR-Train-8549.scene_instance.json", + "./a/ProcTHOR-Train-8664.scene_instance.json", + "./a/ProcTHOR-Train-8809.scene_instance.json", + "./a/ProcTHOR-Train-8340.scene_instance.json", + "./a/ProcTHOR-Train-8869.scene_instance.json", + "./a/ProcTHOR-Train-8480.scene_instance.json", + "./a/ProcTHOR-Train-8129.scene_instance.json", + "./a/ProcTHOR-Train-8395.scene_instance.json", + "./a/ProcTHOR-Train-8685.scene_instance.json", + "./a/ProcTHOR-Train-8040.scene_instance.json", + "./a/ProcTHOR-Train-8811.scene_instance.json", + "./a/ProcTHOR-Train-8984.scene_instance.json", + "./a/ProcTHOR-Train-8270.scene_instance.json", + "./a/ProcTHOR-Train-8760.scene_instance.json", + "./a/ProcTHOR-Train-8174.scene_instance.json", + "./a/ProcTHOR-Train-8042.scene_instance.json", + "./a/ProcTHOR-Train-8397.scene_instance.json", + "./a/ProcTHOR-Train-8085.scene_instance.json", + "./a/ProcTHOR-Train-8473.scene_instance.json", + "./a/ProcTHOR-Train-8816.scene_instance.json", + "./a/ProcTHOR-Train-8066.scene_instance.json", + "./a/ProcTHOR-Train-8499.scene_instance.json", + "./a/ProcTHOR-Train-8695.scene_instance.json", + "./a/ProcTHOR-Train-8937.scene_instance.json", + "./a/ProcTHOR-Train-8319.scene_instance.json", + "./a/ProcTHOR-Train-8354.scene_instance.json", + "./a/ProcTHOR-Train-8496.scene_instance.json", + "./a/ProcTHOR-Train-8840.scene_instance.json", + "./a/ProcTHOR-Train-8268.scene_instance.json", + "./a/ProcTHOR-Train-8632.scene_instance.json", + "./a/ProcTHOR-Train-8697.scene_instance.json", + "./a/ProcTHOR-Train-8659.scene_instance.json", + "./a/ProcTHOR-Train-8253.scene_instance.json", + "./a/ProcTHOR-Train-8218.scene_instance.json", + "./a/ProcTHOR-Train-8298.scene_instance.json", + "./a/ProcTHOR-Train-8726.scene_instance.json", + "./a/ProcTHOR-Train-8502.scene_instance.json", + "./a/ProcTHOR-Train-8187.scene_instance.json", + "./a/ProcTHOR-Train-8058.scene_instance.json", + "./a/ProcTHOR-Train-8535.scene_instance.json", + "./a/ProcTHOR-Train-8346.scene_instance.json", + "./a/ProcTHOR-Train-8702.scene_instance.json", + "./a/ProcTHOR-Train-8021.scene_instance.json", + "./a/ProcTHOR-Train-8862.scene_instance.json", + "./a/ProcTHOR-Train-8335.scene_instance.json", + "./a/ProcTHOR-Train-8940.scene_instance.json", + "./a/ProcTHOR-Train-8097.scene_instance.json", + "./a/ProcTHOR-Train-8189.scene_instance.json", + "./a/ProcTHOR-Train-8029.scene_instance.json", + "./a/ProcTHOR-Train-8757.scene_instance.json", + "./a/ProcTHOR-Train-8791.scene_instance.json", + "./a/ProcTHOR-Train-8929.scene_instance.json", + "./a/ProcTHOR-Train-8111.scene_instance.json", + "./a/ProcTHOR-Train-8615.scene_instance.json", + "./a/ProcTHOR-Train-8500.scene_instance.json", + "./a/ProcTHOR-Train-8751.scene_instance.json", + "./a/ProcTHOR-Train-8259.scene_instance.json", + "./a/ProcTHOR-Train-8437.scene_instance.json", + "./a/ProcTHOR-Train-8165.scene_instance.json", + "./a/ProcTHOR-Train-8598.scene_instance.json", + "./a/ProcTHOR-Train-8368.scene_instance.json", + "./a/ProcTHOR-Train-8580.scene_instance.json", + "./a/ProcTHOR-Train-8756.scene_instance.json", + "./a/ProcTHOR-Train-8979.scene_instance.json", + "./a/ProcTHOR-Train-8016.scene_instance.json", + "./a/ProcTHOR-Train-8601.scene_instance.json", + "./a/ProcTHOR-Train-8015.scene_instance.json", + "./a/ProcTHOR-Train-8978.scene_instance.json", + "./a/ProcTHOR-Train-8985.scene_instance.json", + "./a/ProcTHOR-Train-8127.scene_instance.json", + "./a/ProcTHOR-Train-8403.scene_instance.json", + "./a/ProcTHOR-Train-8843.scene_instance.json", + "./a/ProcTHOR-Train-8935.scene_instance.json", + "./a/ProcTHOR-Train-8707.scene_instance.json", + "./a/ProcTHOR-Train-8595.scene_instance.json", + "./a/ProcTHOR-Train-8293.scene_instance.json", + "./a/ProcTHOR-Train-8926.scene_instance.json", + "./a/ProcTHOR-Train-8429.scene_instance.json", + "./a/ProcTHOR-Train-8703.scene_instance.json", + "./a/ProcTHOR-Train-8555.scene_instance.json", + "./a/ProcTHOR-Train-8103.scene_instance.json", + "./a/ProcTHOR-Train-8310.scene_instance.json", + "./a/ProcTHOR-Train-8242.scene_instance.json", + "./a/ProcTHOR-Train-8039.scene_instance.json", + "./a/ProcTHOR-Train-8898.scene_instance.json", + "./a/ProcTHOR-Train-8951.scene_instance.json", + "./a/ProcTHOR-Train-8048.scene_instance.json", + "./a/ProcTHOR-Train-8699.scene_instance.json", + "./a/ProcTHOR-Train-8379.scene_instance.json", + "./a/ProcTHOR-Train-8286.scene_instance.json", + "./a/ProcTHOR-Train-8283.scene_instance.json", + "./a/ProcTHOR-Train-8914.scene_instance.json", + "./a/ProcTHOR-Train-8797.scene_instance.json", + "./a/ProcTHOR-Train-8071.scene_instance.json", + "./a/ProcTHOR-Train-8153.scene_instance.json", + "./a/ProcTHOR-Train-8790.scene_instance.json", + "./a/ProcTHOR-Train-8059.scene_instance.json", + "./a/ProcTHOR-Train-8229.scene_instance.json", + "./a/ProcTHOR-Train-8573.scene_instance.json", + "./a/ProcTHOR-Train-8013.scene_instance.json", + "./a/ProcTHOR-Train-8472.scene_instance.json", + "./a/ProcTHOR-Train-8547.scene_instance.json", + "./a/ProcTHOR-Train-8445.scene_instance.json", + "./a/ProcTHOR-Train-8660.scene_instance.json", + "./a/ProcTHOR-Train-8962.scene_instance.json", + "./a/ProcTHOR-Train-8769.scene_instance.json", + "./a/ProcTHOR-Train-8476.scene_instance.json", + "./a/ProcTHOR-Train-8216.scene_instance.json", + "./a/ProcTHOR-Train-8857.scene_instance.json", + "./a/ProcTHOR-Train-8451.scene_instance.json", + "./a/ProcTHOR-Train-8321.scene_instance.json", + "./a/ProcTHOR-Train-8005.scene_instance.json", + "./a/ProcTHOR-Train-8621.scene_instance.json", + "./a/ProcTHOR-Train-8678.scene_instance.json", + "./a/ProcTHOR-Train-8834.scene_instance.json", + "./a/ProcTHOR-Train-8047.scene_instance.json", + "./a/ProcTHOR-Train-8130.scene_instance.json", + "./a/ProcTHOR-Train-8908.scene_instance.json", + "./a/ProcTHOR-Train-8382.scene_instance.json", + "./a/ProcTHOR-Train-8239.scene_instance.json", + "./a/ProcTHOR-Train-8322.scene_instance.json", + "./a/ProcTHOR-Train-8399.scene_instance.json", + "./a/ProcTHOR-Train-8950.scene_instance.json", + "./a/ProcTHOR-Train-8987.scene_instance.json", + "./a/ProcTHOR-Train-8587.scene_instance.json", + "./a/ProcTHOR-Train-8360.scene_instance.json", + "./a/ProcTHOR-Train-8136.scene_instance.json", + "./a/ProcTHOR-Train-8600.scene_instance.json", + "./a/ProcTHOR-Train-8637.scene_instance.json", + "./a/ProcTHOR-Train-8774.scene_instance.json", + "./a/ProcTHOR-Train-8735.scene_instance.json", + "./a/ProcTHOR-Train-8643.scene_instance.json", + "./a/ProcTHOR-Train-8924.scene_instance.json", + "./a/ProcTHOR-Train-8687.scene_instance.json", + "./a/ProcTHOR-Train-8211.scene_instance.json", + "./a/ProcTHOR-Train-8277.scene_instance.json", + "./a/ProcTHOR-Train-8823.scene_instance.json", + "./a/ProcTHOR-Train-8289.scene_instance.json", + "./a/ProcTHOR-Train-8639.scene_instance.json", + "./a/ProcTHOR-Train-8195.scene_instance.json", + "./a/ProcTHOR-Train-8613.scene_instance.json", + "./a/ProcTHOR-Train-8720.scene_instance.json", + "./a/ProcTHOR-Train-8841.scene_instance.json", + "./a/ProcTHOR-Train-8591.scene_instance.json", + "./a/ProcTHOR-Train-8716.scene_instance.json", + "./a/ProcTHOR-Train-8133.scene_instance.json", + "./a/ProcTHOR-Train-8250.scene_instance.json", + "./a/ProcTHOR-Train-8567.scene_instance.json", + "./a/ProcTHOR-Train-8313.scene_instance.json", + "./a/ProcTHOR-Train-8069.scene_instance.json", + "./a/ProcTHOR-Train-8629.scene_instance.json", + "./a/ProcTHOR-Train-8428.scene_instance.json", + "./a/ProcTHOR-Train-8117.scene_instance.json", + "./a/ProcTHOR-Train-8484.scene_instance.json", + "./a/ProcTHOR-Train-8301.scene_instance.json", + "./a/ProcTHOR-Train-8061.scene_instance.json", + "./a/ProcTHOR-Train-8526.scene_instance.json", + "./a/ProcTHOR-Train-8581.scene_instance.json", + "./a/ProcTHOR-Train-8142.scene_instance.json", + "./a/ProcTHOR-Train-8116.scene_instance.json", + "./a/ProcTHOR-Train-8065.scene_instance.json", + "./a/ProcTHOR-Train-8689.scene_instance.json", + "./a/ProcTHOR-Train-8359.scene_instance.json", + "./a/ProcTHOR-Train-8633.scene_instance.json", + "./a/ProcTHOR-Train-8714.scene_instance.json", + "./a/ProcTHOR-Train-8546.scene_instance.json", + "./a/ProcTHOR-Train-8815.scene_instance.json", + "./a/ProcTHOR-Train-8585.scene_instance.json", + "./a/ProcTHOR-Train-8534.scene_instance.json", + "./a/ProcTHOR-Train-8763.scene_instance.json", + "./a/ProcTHOR-Train-8385.scene_instance.json", + "./a/ProcTHOR-Train-8831.scene_instance.json", + "./a/ProcTHOR-Train-8710.scene_instance.json", + "./a/ProcTHOR-Train-8150.scene_instance.json", + "./a/ProcTHOR-Train-8246.scene_instance.json", + "./a/ProcTHOR-Train-8274.scene_instance.json", + "./a/ProcTHOR-Train-8287.scene_instance.json", + "./a/ProcTHOR-Train-8766.scene_instance.json", + "./a/ProcTHOR-Train-8913.scene_instance.json", + "./a/ProcTHOR-Train-8288.scene_instance.json", + "./a/ProcTHOR-Train-8835.scene_instance.json", + "./a/ProcTHOR-Train-8089.scene_instance.json", + "./a/ProcTHOR-Train-8203.scene_instance.json", + "./a/ProcTHOR-Train-8939.scene_instance.json", + "./a/ProcTHOR-Train-8386.scene_instance.json", + "./a/ProcTHOR-Train-8067.scene_instance.json", + "./a/ProcTHOR-Train-8461.scene_instance.json", + "./a/ProcTHOR-Train-8099.scene_instance.json", + "./a/ProcTHOR-Train-8881.scene_instance.json", + "./a/ProcTHOR-Train-8446.scene_instance.json", + "./a/ProcTHOR-Train-8602.scene_instance.json", + "./a/ProcTHOR-Train-8550.scene_instance.json", + "./a/ProcTHOR-Train-8255.scene_instance.json", + "./a/ProcTHOR-Train-8454.scene_instance.json", + "./a/ProcTHOR-Train-8560.scene_instance.json", + "./a/ProcTHOR-Train-8309.scene_instance.json", + "./a/ProcTHOR-Train-8925.scene_instance.json", + "./a/ProcTHOR-Train-8409.scene_instance.json", + "./a/ProcTHOR-Train-8983.scene_instance.json", + "./a/ProcTHOR-Train-8554.scene_instance.json", + "./a/ProcTHOR-Train-8199.scene_instance.json", + "./a/ProcTHOR-Train-8858.scene_instance.json", + "./a/ProcTHOR-Train-8485.scene_instance.json", + "./c/ProcTHOR-Val-384.scene_instance.json", + "./c/ProcTHOR-Val-24.scene_instance.json", + "./c/ProcTHOR-Val-541.scene_instance.json", + "./c/ProcTHOR-Val-765.scene_instance.json", + "./c/ProcTHOR-Val-605.scene_instance.json", + "./c/ProcTHOR-Val-410.scene_instance.json", + "./c/ProcTHOR-Val-732.scene_instance.json", + "./c/ProcTHOR-Val-412.scene_instance.json", + "./c/ProcTHOR-Val-643.scene_instance.json", + "./c/ProcTHOR-Val-235.scene_instance.json", + "./c/ProcTHOR-Val-183.scene_instance.json", + "./c/ProcTHOR-Val-355.scene_instance.json", + "./c/ProcTHOR-Val-159.scene_instance.json", + "./c/ProcTHOR-Val-878.scene_instance.json", + "./c/ProcTHOR-Val-242.scene_instance.json", + "./c/ProcTHOR-Val-19.scene_instance.json", + "./c/ProcTHOR-Val-873.scene_instance.json", + "./c/ProcTHOR-Val-550.scene_instance.json", + "./c/ProcTHOR-Val-51.scene_instance.json", + "./c/ProcTHOR-Val-942.scene_instance.json", + "./c/ProcTHOR-Val-134.scene_instance.json", + "./c/ProcTHOR-Val-454.scene_instance.json", + "./c/ProcTHOR-Val-807.scene_instance.json", + "./c/ProcTHOR-Val-909.scene_instance.json", + "./c/ProcTHOR-Val-555.scene_instance.json", + "./c/ProcTHOR-Val-273.scene_instance.json", + "./c/ProcTHOR-Val-302.scene_instance.json", + "./c/ProcTHOR-Val-36.scene_instance.json", + "./c/ProcTHOR-Val-462.scene_instance.json", + "./c/ProcTHOR-Val-147.scene_instance.json", + "./c/ProcTHOR-Val-118.scene_instance.json", + "./c/ProcTHOR-Val-881.scene_instance.json", + "./c/ProcTHOR-Val-39.scene_instance.json", + "./c/ProcTHOR-Val-939.scene_instance.json", + "./c/ProcTHOR-Val-67.scene_instance.json", + "./c/ProcTHOR-Val-154.scene_instance.json", + "./c/ProcTHOR-Val-89.scene_instance.json", + "./c/ProcTHOR-Val-342.scene_instance.json", + "./c/ProcTHOR-Val-372.scene_instance.json", + "./c/ProcTHOR-Val-574.scene_instance.json", + "./c/ProcTHOR-Val-894.scene_instance.json", + "./c/ProcTHOR-Val-75.scene_instance.json", + "./c/ProcTHOR-Val-270.scene_instance.json", + "./c/ProcTHOR-Val-710.scene_instance.json", + "./c/ProcTHOR-Val-885.scene_instance.json", + "./c/ProcTHOR-Val-419.scene_instance.json", + "./c/ProcTHOR-Val-687.scene_instance.json", + "./c/ProcTHOR-Val-828.scene_instance.json", + "./c/ProcTHOR-Val-957.scene_instance.json", + "./c/ProcTHOR-Val-396.scene_instance.json", + "./c/ProcTHOR-Val-88.scene_instance.json", + "./c/ProcTHOR-Val-515.scene_instance.json", + "./c/ProcTHOR-Val-68.scene_instance.json", + "./c/ProcTHOR-Val-874.scene_instance.json", + "./c/ProcTHOR-Val-557.scene_instance.json", + "./c/ProcTHOR-Val-283.scene_instance.json", + "./c/ProcTHOR-Val-227.scene_instance.json", + "./c/ProcTHOR-Val-382.scene_instance.json", + "./c/ProcTHOR-Val-796.scene_instance.json", + "./c/ProcTHOR-Val-764.scene_instance.json", + "./c/ProcTHOR-Val-712.scene_instance.json", + "./c/ProcTHOR-Val-366.scene_instance.json", + "./c/ProcTHOR-Val-704.scene_instance.json", + "./c/ProcTHOR-Val-995.scene_instance.json", + "./c/ProcTHOR-Val-889.scene_instance.json", + "./c/ProcTHOR-Val-565.scene_instance.json", + "./c/ProcTHOR-Val-171.scene_instance.json", + "./c/ProcTHOR-Val-669.scene_instance.json", + "./c/ProcTHOR-Val-112.scene_instance.json", + "./c/ProcTHOR-Val-665.scene_instance.json", + "./c/ProcTHOR-Val-992.scene_instance.json", + "./c/ProcTHOR-Val-722.scene_instance.json", + "./c/ProcTHOR-Val-695.scene_instance.json", + "./c/ProcTHOR-Val-983.scene_instance.json", + "./c/ProcTHOR-Val-70.scene_instance.json", + "./c/ProcTHOR-Val-609.scene_instance.json", + "./c/ProcTHOR-Val-720.scene_instance.json", + "./c/ProcTHOR-Val-94.scene_instance.json", + "./c/ProcTHOR-Val-535.scene_instance.json", + "./c/ProcTHOR-Val-899.scene_instance.json", + "./c/ProcTHOR-Val-686.scene_instance.json", + "./c/ProcTHOR-Val-664.scene_instance.json", + "./c/ProcTHOR-Val-168.scene_instance.json", + "./c/ProcTHOR-Val-476.scene_instance.json", + "./c/ProcTHOR-Val-185.scene_instance.json", + "./c/ProcTHOR-Val-421.scene_instance.json", + "./c/ProcTHOR-Val-966.scene_instance.json", + "./c/ProcTHOR-Val-846.scene_instance.json", + "./c/ProcTHOR-Val-685.scene_instance.json", + "./c/ProcTHOR-Val-34.scene_instance.json", + "./c/ProcTHOR-Val-588.scene_instance.json", + "./c/ProcTHOR-Val-189.scene_instance.json", + "./c/ProcTHOR-Val-569.scene_instance.json", + "./c/ProcTHOR-Val-561.scene_instance.json", + "./c/ProcTHOR-Val-578.scene_instance.json", + "./c/ProcTHOR-Val-439.scene_instance.json", + "./c/ProcTHOR-Val-309.scene_instance.json", + "./c/ProcTHOR-Val-867.scene_instance.json", + "./c/ProcTHOR-Val-145.scene_instance.json", + "./c/ProcTHOR-Val-122.scene_instance.json", + "./c/ProcTHOR-Val-47.scene_instance.json", + "./c/ProcTHOR-Val-316.scene_instance.json", + "./c/ProcTHOR-Val-996.scene_instance.json", + "./c/ProcTHOR-Val-124.scene_instance.json", + "./c/ProcTHOR-Val-169.scene_instance.json", + "./c/ProcTHOR-Val-184.scene_instance.json", + "./c/ProcTHOR-Val-358.scene_instance.json", + "./c/ProcTHOR-Val-682.scene_instance.json", + "./c/ProcTHOR-Val-138.scene_instance.json", + "./c/ProcTHOR-Val-717.scene_instance.json", + "./c/ProcTHOR-Val-304.scene_instance.json", + "./c/ProcTHOR-Val-377.scene_instance.json", + "./c/ProcTHOR-Val-917.scene_instance.json", + "./c/ProcTHOR-Val-336.scene_instance.json", + "./c/ProcTHOR-Val-26.scene_instance.json", + "./c/ProcTHOR-Val-385.scene_instance.json", + "./c/ProcTHOR-Val-940.scene_instance.json", + "./c/ProcTHOR-Val-573.scene_instance.json", + "./c/ProcTHOR-Val-658.scene_instance.json", + "./c/ProcTHOR-Val-392.scene_instance.json", + "./c/ProcTHOR-Val-924.scene_instance.json", + "./c/ProcTHOR-Val-218.scene_instance.json", + "./c/ProcTHOR-Val-526.scene_instance.json", + "./c/ProcTHOR-Val-657.scene_instance.json", + "./c/ProcTHOR-Val-226.scene_instance.json", + "./c/ProcTHOR-Val-228.scene_instance.json", + "./c/ProcTHOR-Val-973.scene_instance.json", + "./c/ProcTHOR-Val-287.scene_instance.json", + "./c/ProcTHOR-Val-432.scene_instance.json", + "./c/ProcTHOR-Val-964.scene_instance.json", + "./c/ProcTHOR-Val-907.scene_instance.json", + "./c/ProcTHOR-Val-422.scene_instance.json", + "./c/ProcTHOR-Val-753.scene_instance.json", + "./c/ProcTHOR-Val-260.scene_instance.json", + "./c/ProcTHOR-Val-536.scene_instance.json", + "./c/ProcTHOR-Val-774.scene_instance.json", + "./c/ProcTHOR-Val-359.scene_instance.json", + "./c/ProcTHOR-Val-229.scene_instance.json", + "./c/ProcTHOR-Val-167.scene_instance.json", + "./c/ProcTHOR-Val-205.scene_instance.json", + "./c/ProcTHOR-Val-101.scene_instance.json", + "./c/ProcTHOR-Val-163.scene_instance.json", + "./c/ProcTHOR-Val-408.scene_instance.json", + "./c/ProcTHOR-Val-744.scene_instance.json", + "./c/ProcTHOR-Val-735.scene_instance.json", + "./c/ProcTHOR-Val-855.scene_instance.json", + "./c/ProcTHOR-Val-955.scene_instance.json", + "./c/ProcTHOR-Val-367.scene_instance.json", + "./c/ProcTHOR-Val-611.scene_instance.json", + "./c/ProcTHOR-Val-734.scene_instance.json", + "./c/ProcTHOR-Val-998.scene_instance.json", + "./c/ProcTHOR-Val-875.scene_instance.json", + "./c/ProcTHOR-Val-729.scene_instance.json", + "./c/ProcTHOR-Val-743.scene_instance.json", + "./c/ProcTHOR-Val-262.scene_instance.json", + "./c/ProcTHOR-Val-663.scene_instance.json", + "./c/ProcTHOR-Val-648.scene_instance.json", + "./c/ProcTHOR-Val-347.scene_instance.json", + "./c/ProcTHOR-Val-48.scene_instance.json", + "./c/ProcTHOR-Val-115.scene_instance.json", + "./c/ProcTHOR-Val-387.scene_instance.json", + "./c/ProcTHOR-Val-786.scene_instance.json", + "./c/ProcTHOR-Val-64.scene_instance.json", + "./c/ProcTHOR-Val-590.scene_instance.json", + "./c/ProcTHOR-Val-842.scene_instance.json", + "./c/ProcTHOR-Val-28.scene_instance.json", + "./c/ProcTHOR-Val-180.scene_instance.json", + "./c/ProcTHOR-Val-274.scene_instance.json", + "./c/ProcTHOR-Val-30.scene_instance.json", + "./c/ProcTHOR-Val-371.scene_instance.json", + "./c/ProcTHOR-Val-577.scene_instance.json", + "./c/ProcTHOR-Val-271.scene_instance.json", + "./c/ProcTHOR-Val-854.scene_instance.json", + "./c/ProcTHOR-Val-739.scene_instance.json", + "./c/ProcTHOR-Val-591.scene_instance.json", + "./c/ProcTHOR-Val-197.scene_instance.json", + "./c/ProcTHOR-Val-129.scene_instance.json", + "./c/ProcTHOR-Val-192.scene_instance.json", + "./c/ProcTHOR-Val-864.scene_instance.json", + "./c/ProcTHOR-Val-805.scene_instance.json", + "./c/ProcTHOR-Val-424.scene_instance.json", + "./c/ProcTHOR-Val-16.scene_instance.json", + "./c/ProcTHOR-Val-406.scene_instance.json", + "./c/ProcTHOR-Val-812.scene_instance.json", + "./c/ProcTHOR-Val-770.scene_instance.json", + "./c/ProcTHOR-Val-511.scene_instance.json", + "./c/ProcTHOR-Val-543.scene_instance.json", + "./c/ProcTHOR-Val-519.scene_instance.json", + "./c/ProcTHOR-Val-622.scene_instance.json", + "./c/ProcTHOR-Val-757.scene_instance.json", + "./c/ProcTHOR-Val-858.scene_instance.json", + "./c/ProcTHOR-Val-824.scene_instance.json", + "./c/ProcTHOR-Val-507.scene_instance.json", + "./c/ProcTHOR-Val-409.scene_instance.json", + "./c/ProcTHOR-Val-562.scene_instance.json", + "./c/ProcTHOR-Val-365.scene_instance.json", + "./c/ProcTHOR-Val-317.scene_instance.json", + "./c/ProcTHOR-Val-113.scene_instance.json", + "./c/ProcTHOR-Val-158.scene_instance.json", + "./c/ProcTHOR-Val-960.scene_instance.json", + "./c/ProcTHOR-Val-646.scene_instance.json", + "./c/ProcTHOR-Val-445.scene_instance.json", + "./c/ProcTHOR-Val-806.scene_instance.json", + "./c/ProcTHOR-Val-435.scene_instance.json", + "./c/ProcTHOR-Val-509.scene_instance.json", + "./c/ProcTHOR-Val-284.scene_instance.json", + "./c/ProcTHOR-Val-443.scene_instance.json", + "./c/ProcTHOR-Val-971.scene_instance.json", + "./c/ProcTHOR-Val-775.scene_instance.json", + "./c/ProcTHOR-Val-833.scene_instance.json", + "./c/ProcTHOR-Val-380.scene_instance.json", + "./c/ProcTHOR-Val-240.scene_instance.json", + "./c/ProcTHOR-Val-352.scene_instance.json", + "./c/ProcTHOR-Val-763.scene_instance.json", + "./c/ProcTHOR-Val-970.scene_instance.json", + "./c/ProcTHOR-Val-73.scene_instance.json", + "./c/ProcTHOR-Val-369.scene_instance.json", + "./c/ProcTHOR-Val-740.scene_instance.json", + "./c/ProcTHOR-Val-346.scene_instance.json", + "./c/ProcTHOR-Val-368.scene_instance.json", + "./c/ProcTHOR-Val-694.scene_instance.json", + "./c/ProcTHOR-Val-655.scene_instance.json", + "./c/ProcTHOR-Val-35.scene_instance.json", + "./c/ProcTHOR-Val-402.scene_instance.json", + "./c/ProcTHOR-Val-53.scene_instance.json", + "./c/ProcTHOR-Val-827.scene_instance.json", + "./c/ProcTHOR-Val-390.scene_instance.json", + "./c/ProcTHOR-Val-295.scene_instance.json", + "./c/ProcTHOR-Val-908.scene_instance.json", + "./c/ProcTHOR-Val-31.scene_instance.json", + "./c/ProcTHOR-Val-816.scene_instance.json", + "./c/ProcTHOR-Val-693.scene_instance.json", + "./c/ProcTHOR-Val-882.scene_instance.json", + "./c/ProcTHOR-Val-871.scene_instance.json", + "./c/ProcTHOR-Val-776.scene_instance.json", + "./c/ProcTHOR-Val-170.scene_instance.json", + "./c/ProcTHOR-Val-959.scene_instance.json", + "./c/ProcTHOR-Val-155.scene_instance.json", + "./c/ProcTHOR-Val-164.scene_instance.json", + "./c/ProcTHOR-Val-699.scene_instance.json", + "./c/ProcTHOR-Val-285.scene_instance.json", + "./c/ProcTHOR-Val-771.scene_instance.json", + "./c/ProcTHOR-Val-865.scene_instance.json", + "./c/ProcTHOR-Val-25.scene_instance.json", + "./c/ProcTHOR-Val-628.scene_instance.json", + "./c/ProcTHOR-Val-594.scene_instance.json", + "./c/ProcTHOR-Val-18.scene_instance.json", + "./c/ProcTHOR-Val-389.scene_instance.json", + "./c/ProcTHOR-Val-357.scene_instance.json", + "./c/ProcTHOR-Val-376.scene_instance.json", + "./c/ProcTHOR-Val-709.scene_instance.json", + "./c/ProcTHOR-Val-554.scene_instance.json", + "./c/ProcTHOR-Val-892.scene_instance.json", + "./c/ProcTHOR-Val-398.scene_instance.json", + "./c/ProcTHOR-Val-943.scene_instance.json", + "./c/ProcTHOR-Val-990.scene_instance.json", + "./c/ProcTHOR-Val-823.scene_instance.json", + "./c/ProcTHOR-Val-477.scene_instance.json", + "./c/ProcTHOR-Val-553.scene_instance.json", + "./c/ProcTHOR-Val-513.scene_instance.json", + "./c/ProcTHOR-Val-186.scene_instance.json", + "./c/ProcTHOR-Val-442.scene_instance.json", + "./c/ProcTHOR-Val-12.scene_instance.json", + "./c/ProcTHOR-Val-152.scene_instance.json", + "./c/ProcTHOR-Val-8.scene_instance.json", + "./c/ProcTHOR-Val-650.scene_instance.json", + "./c/ProcTHOR-Val-952.scene_instance.json", + "./c/ProcTHOR-Val-619.scene_instance.json", + "./c/ProcTHOR-Val-521.scene_instance.json", + "./c/ProcTHOR-Val-933.scene_instance.json", + "./c/ProcTHOR-Val-320.scene_instance.json", + "./c/ProcTHOR-Val-905.scene_instance.json", + "./c/ProcTHOR-Val-705.scene_instance.json", + "./c/ProcTHOR-Val-141.scene_instance.json", + "./c/ProcTHOR-Val-312.scene_instance.json", + "./c/ProcTHOR-Val-564.scene_instance.json", + "./c/ProcTHOR-Val-272.scene_instance.json", + "./c/ProcTHOR-Val-614.scene_instance.json", + "./c/ProcTHOR-Val-93.scene_instance.json", + "./c/ProcTHOR-Val-499.scene_instance.json", + "./c/ProcTHOR-Val-684.scene_instance.json", + "./c/ProcTHOR-Val-826.scene_instance.json", + "./c/ProcTHOR-Val-938.scene_instance.json", + "./c/ProcTHOR-Val-293.scene_instance.json", + "./c/ProcTHOR-Val-339.scene_instance.json", + "./c/ProcTHOR-Val-404.scene_instance.json", + "./c/ProcTHOR-Val-395.scene_instance.json", + "./c/ProcTHOR-Val-629.scene_instance.json", + "./c/ProcTHOR-Val-768.scene_instance.json", + "./c/ProcTHOR-Val-677.scene_instance.json", + "./c/ProcTHOR-Val-551.scene_instance.json", + "./c/ProcTHOR-Val-929.scene_instance.json", + "./c/ProcTHOR-Val-741.scene_instance.json", + "./c/ProcTHOR-Val-483.scene_instance.json", + "./c/ProcTHOR-Val-781.scene_instance.json", + "./c/ProcTHOR-Val-949.scene_instance.json", + "./c/ProcTHOR-Val-692.scene_instance.json", + "./c/ProcTHOR-Val-310.scene_instance.json", + "./c/ProcTHOR-Val-946.scene_instance.json", + "./c/ProcTHOR-Val-144.scene_instance.json", + "./c/ProcTHOR-Val-74.scene_instance.json", + "./c/ProcTHOR-Val-737.scene_instance.json", + "./c/ProcTHOR-Val-520.scene_instance.json", + "./c/ProcTHOR-Val-941.scene_instance.json", + "./c/ProcTHOR-Val-840.scene_instance.json", + "./c/ProcTHOR-Val-296.scene_instance.json", + "./c/ProcTHOR-Val-234.scene_instance.json", + "./c/ProcTHOR-Val-182.scene_instance.json", + "./c/ProcTHOR-Val-162.scene_instance.json", + "./c/ProcTHOR-Val-65.scene_instance.json", + "./c/ProcTHOR-Val-254.scene_instance.json", + "./c/ProcTHOR-Val-27.scene_instance.json", + "./c/ProcTHOR-Val-809.scene_instance.json", + "./c/ProcTHOR-Val-60.scene_instance.json", + "./c/ProcTHOR-Val-934.scene_instance.json", + "./c/ProcTHOR-Val-178.scene_instance.json", + "./c/ProcTHOR-Val-896.scene_instance.json", + "./c/ProcTHOR-Val-548.scene_instance.json", + "./c/ProcTHOR-Val-81.scene_instance.json", + "./c/ProcTHOR-Val-988.scene_instance.json", + "./c/ProcTHOR-Val-963.scene_instance.json", + "./c/ProcTHOR-Val-958.scene_instance.json", + "./c/ProcTHOR-Val-58.scene_instance.json", + "./c/ProcTHOR-Val-450.scene_instance.json", + "./c/ProcTHOR-Val-675.scene_instance.json", + "./c/ProcTHOR-Val-715.scene_instance.json", + "./c/ProcTHOR-Val-895.scene_instance.json", + "./c/ProcTHOR-Val-852.scene_instance.json", + "./c/ProcTHOR-Val-306.scene_instance.json", + "./c/ProcTHOR-Val-44.scene_instance.json", + "./c/ProcTHOR-Val-918.scene_instance.json", + "./c/ProcTHOR-Val-428.scene_instance.json", + "./c/ProcTHOR-Val-224.scene_instance.json", + "./c/ProcTHOR-Val-518.scene_instance.json", + "./c/ProcTHOR-Val-130.scene_instance.json", + "./c/ProcTHOR-Val-897.scene_instance.json", + "./c/ProcTHOR-Val-537.scene_instance.json", + "./c/ProcTHOR-Val-350.scene_instance.json", + "./c/ProcTHOR-Val-976.scene_instance.json", + "./c/ProcTHOR-Val-968.scene_instance.json", + "./c/ProcTHOR-Val-815.scene_instance.json", + "./c/ProcTHOR-Val-672.scene_instance.json", + "./c/ProcTHOR-Val-931.scene_instance.json", + "./c/ProcTHOR-Val-726.scene_instance.json", + "./c/ProcTHOR-Val-256.scene_instance.json", + "./c/ProcTHOR-Val-143.scene_instance.json", + "./c/ProcTHOR-Val-276.scene_instance.json", + "./c/ProcTHOR-Val-606.scene_instance.json", + "./c/ProcTHOR-Val-473.scene_instance.json", + "./c/ProcTHOR-Val-951.scene_instance.json", + "./c/ProcTHOR-Val-849.scene_instance.json", + "./c/ProcTHOR-Val-480.scene_instance.json", + "./c/ProcTHOR-Val-233.scene_instance.json", + "./c/ProcTHOR-Val-853.scene_instance.json", + "./c/ProcTHOR-Val-61.scene_instance.json", + "./c/ProcTHOR-Val-851.scene_instance.json", + "./c/ProcTHOR-Val-146.scene_instance.json", + "./c/ProcTHOR-Val-298.scene_instance.json", + "./c/ProcTHOR-Val-592.scene_instance.json", + "./c/ProcTHOR-Val-332.scene_instance.json", + "./c/ProcTHOR-Val-784.scene_instance.json", + "./c/ProcTHOR-Val-487.scene_instance.json", + "./c/ProcTHOR-Val-43.scene_instance.json", + "./c/ProcTHOR-Val-922.scene_instance.json", + "./c/ProcTHOR-Val-290.scene_instance.json", + "./c/ProcTHOR-Val-639.scene_instance.json", + "./c/ProcTHOR-Val-898.scene_instance.json", + "./c/ProcTHOR-Val-713.scene_instance.json", + "./c/ProcTHOR-Val-528.scene_instance.json", + "./c/ProcTHOR-Val-501.scene_instance.json", + "./c/ProcTHOR-Val-331.scene_instance.json", + "./c/ProcTHOR-Val-393.scene_instance.json", + "./c/ProcTHOR-Val-773.scene_instance.json", + "./c/ProcTHOR-Val-861.scene_instance.json", + "./c/ProcTHOR-Val-721.scene_instance.json", + "./c/ProcTHOR-Val-22.scene_instance.json", + "./c/ProcTHOR-Val-718.scene_instance.json", + "./c/ProcTHOR-Val-394.scene_instance.json", + "./c/ProcTHOR-Val-883.scene_instance.json", + "./c/ProcTHOR-Val-620.scene_instance.json", + "./c/ProcTHOR-Val-479.scene_instance.json", + "./c/ProcTHOR-Val-832.scene_instance.json", + "./c/ProcTHOR-Val-627.scene_instance.json", + "./c/ProcTHOR-Val-323.scene_instance.json", + "./c/ProcTHOR-Val-313.scene_instance.json", + "./c/ProcTHOR-Val-92.scene_instance.json", + "./c/ProcTHOR-Val-17.scene_instance.json", + "./c/ProcTHOR-Val-201.scene_instance.json", + "./c/ProcTHOR-Val-950.scene_instance.json", + "./c/ProcTHOR-Val-903.scene_instance.json", + "./c/ProcTHOR-Val-102.scene_instance.json", + "./c/ProcTHOR-Val-728.scene_instance.json", + "./c/ProcTHOR-Val-451.scene_instance.json", + "./c/ProcTHOR-Val-388.scene_instance.json", + "./c/ProcTHOR-Val-181.scene_instance.json", + "./c/ProcTHOR-Val-333.scene_instance.json", + "./c/ProcTHOR-Val-500.scene_instance.json", + "./c/ProcTHOR-Val-494.scene_instance.json", + "./c/ProcTHOR-Val-549.scene_instance.json", + "./c/ProcTHOR-Val-381.scene_instance.json", + "./c/ProcTHOR-Val-436.scene_instance.json", + "./c/ProcTHOR-Val-245.scene_instance.json", + "./c/ProcTHOR-Val-876.scene_instance.json", + "./c/ProcTHOR-Val-597.scene_instance.json", + "./c/ProcTHOR-Val-945.scene_instance.json", + "./c/ProcTHOR-Val-353.scene_instance.json", + "./c/ProcTHOR-Val-119.scene_instance.json", + "./c/ProcTHOR-Val-213.scene_instance.json", + "./c/ProcTHOR-Val-343.scene_instance.json", + "./c/ProcTHOR-Val-800.scene_instance.json", + "./c/ProcTHOR-Val-989.scene_instance.json", + "./c/ProcTHOR-Val-821.scene_instance.json", + "./c/ProcTHOR-Val-977.scene_instance.json", + "./c/ProcTHOR-Val-268.scene_instance.json", + "./c/ProcTHOR-Val-126.scene_instance.json", + "./c/ProcTHOR-Val-711.scene_instance.json", + "./c/ProcTHOR-Val-546.scene_instance.json", + "./c/ProcTHOR-Val-516.scene_instance.json", + "./c/ProcTHOR-Val-967.scene_instance.json", + "./c/ProcTHOR-Val-222.scene_instance.json", + "./c/ProcTHOR-Val-678.scene_instance.json", + "./c/ProcTHOR-Val-468.scene_instance.json", + "./c/ProcTHOR-Val-156.scene_instance.json", + "./c/ProcTHOR-Val-120.scene_instance.json", + "./c/ProcTHOR-Val-755.scene_instance.json", + "./c/ProcTHOR-Val-530.scene_instance.json", + "./c/ProcTHOR-Val-707.scene_instance.json", + "./c/ProcTHOR-Val-63.scene_instance.json", + "./c/ProcTHOR-Val-808.scene_instance.json", + "./c/ProcTHOR-Val-901.scene_instance.json", + "./c/ProcTHOR-Val-97.scene_instance.json", + "./c/ProcTHOR-Val-289.scene_instance.json", + "./c/ProcTHOR-Val-547.scene_instance.json", + "./c/ProcTHOR-Val-59.scene_instance.json", + "./c/ProcTHOR-Val-540.scene_instance.json", + "./c/ProcTHOR-Val-452.scene_instance.json", + "./c/ProcTHOR-Val-401.scene_instance.json", + "./c/ProcTHOR-Val-906.scene_instance.json", + "./c/ProcTHOR-Val-930.scene_instance.json", + "./c/ProcTHOR-Val-193.scene_instance.json", + "./c/ProcTHOR-Val-708.scene_instance.json", + "./c/ProcTHOR-Val-214.scene_instance.json", + "./c/ProcTHOR-Val-980.scene_instance.json", + "./c/ProcTHOR-Val-54.scene_instance.json", + "./c/ProcTHOR-Val-391.scene_instance.json", + "./c/ProcTHOR-Val-746.scene_instance.json", + "./c/ProcTHOR-Val-66.scene_instance.json", + "./c/ProcTHOR-Val-107.scene_instance.json", + "./c/ProcTHOR-Val-116.scene_instance.json", + "./c/ProcTHOR-Val-496.scene_instance.json", + "./c/ProcTHOR-Val-730.scene_instance.json", + "./c/ProcTHOR-Val-291.scene_instance.json", + "./c/ProcTHOR-Val-993.scene_instance.json", + "./c/ProcTHOR-Val-373.scene_instance.json", + "./c/ProcTHOR-Val-920.scene_instance.json", + "./c/ProcTHOR-Val-20.scene_instance.json", + "./c/ProcTHOR-Val-127.scene_instance.json", + "./c/ProcTHOR-Val-793.scene_instance.json", + "./c/ProcTHOR-Val-236.scene_instance.json", + "./c/ProcTHOR-Val-98.scene_instance.json", + "./c/ProcTHOR-Val-417.scene_instance.json", + "./c/ProcTHOR-Val-585.scene_instance.json", + "./c/ProcTHOR-Val-916.scene_instance.json", + "./c/ProcTHOR-Val-105.scene_instance.json", + "./c/ProcTHOR-Val-2.scene_instance.json", + "./c/ProcTHOR-Val-248.scene_instance.json", + "./c/ProcTHOR-Val-403.scene_instance.json", + "./c/ProcTHOR-Val-475.scene_instance.json", + "./c/ProcTHOR-Val-338.scene_instance.json", + "./c/ProcTHOR-Val-280.scene_instance.json", + "./c/ProcTHOR-Val-440.scene_instance.json", + "./c/ProcTHOR-Val-974.scene_instance.json", + "./c/ProcTHOR-Val-196.scene_instance.json", + "./c/ProcTHOR-Val-844.scene_instance.json", + "./c/ProcTHOR-Val-570.scene_instance.json", + "./c/ProcTHOR-Val-910.scene_instance.json", + "./c/ProcTHOR-Val-502.scene_instance.json", + "./c/ProcTHOR-Val-870.scene_instance.json", + "./c/ProcTHOR-Val-587.scene_instance.json", + "./c/ProcTHOR-Val-659.scene_instance.json", + "./c/ProcTHOR-Val-798.scene_instance.json", + "./c/ProcTHOR-Val-456.scene_instance.json", + "./c/ProcTHOR-Val-797.scene_instance.json", + "./c/ProcTHOR-Val-117.scene_instance.json", + "./c/ProcTHOR-Val-818.scene_instance.json", + "./c/ProcTHOR-Val-261.scene_instance.json", + "./c/ProcTHOR-Val-760.scene_instance.json", + "./c/ProcTHOR-Val-21.scene_instance.json", + "./c/ProcTHOR-Val-303.scene_instance.json", + "./c/ProcTHOR-Val-956.scene_instance.json", + "./c/ProcTHOR-Val-241.scene_instance.json", + "./c/ProcTHOR-Val-96.scene_instance.json", + "./c/ProcTHOR-Val-1.scene_instance.json", + "./c/ProcTHOR-Val-204.scene_instance.json", + "./c/ProcTHOR-Val-888.scene_instance.json", + "./c/ProcTHOR-Val-552.scene_instance.json", + "./c/ProcTHOR-Val-267.scene_instance.json", + "./c/ProcTHOR-Val-231.scene_instance.json", + "./c/ProcTHOR-Val-522.scene_instance.json", + "./c/ProcTHOR-Val-748.scene_instance.json", + "./c/ProcTHOR-Val-632.scene_instance.json", + "./c/ProcTHOR-Val-330.scene_instance.json", + "./c/ProcTHOR-Val-478.scene_instance.json", + "./c/ProcTHOR-Val-57.scene_instance.json", + "./c/ProcTHOR-Val-418.scene_instance.json", + "./c/ProcTHOR-Val-866.scene_instance.json", + "./c/ProcTHOR-Val-378.scene_instance.json", + "./c/ProcTHOR-Val-77.scene_instance.json", + "./c/ProcTHOR-Val-375.scene_instance.json", + "./c/ProcTHOR-Val-72.scene_instance.json", + "./c/ProcTHOR-Val-923.scene_instance.json", + "./c/ProcTHOR-Val-341.scene_instance.json", + "./c/ProcTHOR-Val-676.scene_instance.json", + "./c/ProcTHOR-Val-49.scene_instance.json", + "./c/ProcTHOR-Val-736.scene_instance.json", + "./c/ProcTHOR-Val-825.scene_instance.json", + "./c/ProcTHOR-Val-174.scene_instance.json", + "./c/ProcTHOR-Val-430.scene_instance.json", + "./c/ProcTHOR-Val-76.scene_instance.json", + "./c/ProcTHOR-Val-749.scene_instance.json", + "./c/ProcTHOR-Val-626.scene_instance.json", + "./c/ProcTHOR-Val-566.scene_instance.json", + "./c/ProcTHOR-Val-803.scene_instance.json", + "./c/ProcTHOR-Val-667.scene_instance.json", + "./c/ProcTHOR-Val-856.scene_instance.json", + "./c/ProcTHOR-Val-679.scene_instance.json", + "./c/ProcTHOR-Val-90.scene_instance.json", + "./c/ProcTHOR-Val-560.scene_instance.json", + "./c/ProcTHOR-Val-100.scene_instance.json", + "./c/ProcTHOR-Val-904.scene_instance.json", + "./c/ProcTHOR-Val-759.scene_instance.json", + "./c/ProcTHOR-Val-200.scene_instance.json", + "./c/ProcTHOR-Val-719.scene_instance.json", + "./c/ProcTHOR-Val-572.scene_instance.json", + "./c/ProcTHOR-Val-504.scene_instance.json", + "./c/ProcTHOR-Val-329.scene_instance.json", + "./c/ProcTHOR-Val-288.scene_instance.json", + "./c/ProcTHOR-Val-761.scene_instance.json", + "./c/ProcTHOR-Val-327.scene_instance.json", + "./c/ProcTHOR-Val-666.scene_instance.json", + "./c/ProcTHOR-Val-703.scene_instance.json", + "./c/ProcTHOR-Val-15.scene_instance.json", + "./c/ProcTHOR-Val-301.scene_instance.json", + "./c/ProcTHOR-Val-581.scene_instance.json", + "./c/ProcTHOR-Val-362.scene_instance.json", + "./c/ProcTHOR-Val-642.scene_instance.json", + "./c/ProcTHOR-Val-486.scene_instance.json", + "./c/ProcTHOR-Val-286.scene_instance.json", + "./c/ProcTHOR-Val-762.scene_instance.json", + "./c/ProcTHOR-Val-140.scene_instance.json", + "./c/ProcTHOR-Val-354.scene_instance.json", + "./c/ProcTHOR-Val-71.scene_instance.json", + "./c/ProcTHOR-Val-911.scene_instance.json", + "./c/ProcTHOR-Val-99.scene_instance.json", + "./c/ProcTHOR-Val-772.scene_instance.json", + "./c/ProcTHOR-Val-542.scene_instance.json", + "./c/ProcTHOR-Val-84.scene_instance.json", + "./c/ProcTHOR-Val-6.scene_instance.json", + "./c/ProcTHOR-Val-794.scene_instance.json", + "./c/ProcTHOR-Val-425.scene_instance.json", + "./c/ProcTHOR-Val-467.scene_instance.json", + "./c/ProcTHOR-Val-32.scene_instance.json", + "./c/ProcTHOR-Val-460.scene_instance.json", + "./c/ProcTHOR-Val-769.scene_instance.json", + "./c/ProcTHOR-Val-999.scene_instance.json", + "./c/ProcTHOR-Val-660.scene_instance.json", + "./c/ProcTHOR-Val-300.scene_instance.json", + "./c/ProcTHOR-Val-731.scene_instance.json", + "./c/ProcTHOR-Val-822.scene_instance.json", + "./c/ProcTHOR-Val-239.scene_instance.json", + "./c/ProcTHOR-Val-751.scene_instance.json", + "./c/ProcTHOR-Val-449.scene_instance.json", + "./c/ProcTHOR-Val-654.scene_instance.json", + "./c/ProcTHOR-Val-328.scene_instance.json", + "./c/ProcTHOR-Val-414.scene_instance.json", + "./c/ProcTHOR-Val-752.scene_instance.json", + "./c/ProcTHOR-Val-725.scene_instance.json", + "./c/ProcTHOR-Val-558.scene_instance.json", + "./c/ProcTHOR-Val-278.scene_instance.json", + "./c/ProcTHOR-Val-161.scene_instance.json", + "./c/ProcTHOR-Val-613.scene_instance.json", + "./c/ProcTHOR-Val-457.scene_instance.json", + "./c/ProcTHOR-Val-559.scene_instance.json", + "./c/ProcTHOR-Val-696.scene_instance.json", + "./c/ProcTHOR-Val-617.scene_instance.json", + "./c/ProcTHOR-Val-984.scene_instance.json", + "./c/ProcTHOR-Val-645.scene_instance.json", + "./c/ProcTHOR-Val-360.scene_instance.json", + "./c/ProcTHOR-Val-782.scene_instance.json", + "./c/ProcTHOR-Val-674.scene_instance.json", + "./c/ProcTHOR-Val-935.scene_instance.json", + "./c/ProcTHOR-Val-661.scene_instance.json", + "./c/ProcTHOR-Val-886.scene_instance.json", + "./c/ProcTHOR-Val-915.scene_instance.json", + "./c/ProcTHOR-Val-779.scene_instance.json", + "./c/ProcTHOR-Val-750.scene_instance.json", + "./c/ProcTHOR-Val-297.scene_instance.json", + "./c/ProcTHOR-Val-979.scene_instance.json", + "./c/ProcTHOR-Val-601.scene_instance.json", + "./c/ProcTHOR-Val-91.scene_instance.json", + "./c/ProcTHOR-Val-319.scene_instance.json", + "./c/ProcTHOR-Val-55.scene_instance.json", + "./c/ProcTHOR-Val-282.scene_instance.json", + "./c/ProcTHOR-Val-325.scene_instance.json", + "./c/ProcTHOR-Val-997.scene_instance.json", + "./c/ProcTHOR-Val-733.scene_instance.json", + "./c/ProcTHOR-Val-986.scene_instance.json", + "./c/ProcTHOR-Val-453.scene_instance.json", + "./c/ProcTHOR-Val-149.scene_instance.json", + "./c/ProcTHOR-Val-348.scene_instance.json", + "./c/ProcTHOR-Val-492.scene_instance.json", + "./c/ProcTHOR-Val-884.scene_instance.json", + "./c/ProcTHOR-Val-680.scene_instance.json", + "./c/ProcTHOR-Val-386.scene_instance.json", + "./c/ProcTHOR-Val-532.scene_instance.json", + "./c/ProcTHOR-Val-880.scene_instance.json", + "./c/ProcTHOR-Val-190.scene_instance.json", + "./c/ProcTHOR-Val-62.scene_instance.json", + "./c/ProcTHOR-Val-863.scene_instance.json", + "./c/ProcTHOR-Val-125.scene_instance.json", + "./c/ProcTHOR-Val-344.scene_instance.json", + "./c/ProcTHOR-Val-647.scene_instance.json", + "./c/ProcTHOR-Val-263.scene_instance.json", + "./c/ProcTHOR-Val-363.scene_instance.json", + "./c/ProcTHOR-Val-633.scene_instance.json", + "./c/ProcTHOR-Val-444.scene_instance.json", + "./c/ProcTHOR-Val-139.scene_instance.json", + "./c/ProcTHOR-Val-142.scene_instance.json", + "./c/ProcTHOR-Val-887.scene_instance.json", + "./c/ProcTHOR-Val-914.scene_instance.json", + "./c/ProcTHOR-Val-210.scene_instance.json", + "./c/ProcTHOR-Val-413.scene_instance.json", + "./c/ProcTHOR-Val-817.scene_instance.json", + "./c/ProcTHOR-Val-607.scene_instance.json", + "./c/ProcTHOR-Val-87.scene_instance.json", + "./c/ProcTHOR-Val-321.scene_instance.json", + "./c/ProcTHOR-Val-206.scene_instance.json", + "./c/ProcTHOR-Val-926.scene_instance.json", + "./c/ProcTHOR-Val-747.scene_instance.json", + "./c/ProcTHOR-Val-52.scene_instance.json", + "./c/ProcTHOR-Val-493.scene_instance.json", + "./c/ProcTHOR-Val-148.scene_instance.json", + "./c/ProcTHOR-Val-132.scene_instance.json", + "./c/ProcTHOR-Val-589.scene_instance.json", + "./c/ProcTHOR-Val-474.scene_instance.json", + "./c/ProcTHOR-Val-701.scene_instance.json", + "./c/ProcTHOR-Val-954.scene_instance.json", + "./c/ProcTHOR-Val-868.scene_instance.json", + "./c/ProcTHOR-Val-637.scene_instance.json", + "./c/ProcTHOR-Val-383.scene_instance.json", + "./c/ProcTHOR-Val-698.scene_instance.json", + "./c/ProcTHOR-Val-11.scene_instance.json", + "./c/ProcTHOR-Val-257.scene_instance.json", + "./c/ProcTHOR-Val-379.scene_instance.json", + "./c/ProcTHOR-Val-683.scene_instance.json", + "./c/ProcTHOR-Val-576.scene_instance.json", + "./c/ProcTHOR-Val-128.scene_instance.json", + "./c/ProcTHOR-Val-420.scene_instance.json", + "./c/ProcTHOR-Val-575.scene_instance.json", + "./c/ProcTHOR-Val-469.scene_instance.json", + "./c/ProcTHOR-Val-845.scene_instance.json", + "./c/ProcTHOR-Val-780.scene_instance.json", + "./c/ProcTHOR-Val-766.scene_instance.json", + "./c/ProcTHOR-Val-610.scene_instance.json", + "./c/ProcTHOR-Val-987.scene_instance.json", + "./c/ProcTHOR-Val-38.scene_instance.json", + "./c/ProcTHOR-Val-670.scene_instance.json", + "./c/ProcTHOR-Val-264.scene_instance.json", + "./c/ProcTHOR-Val-859.scene_instance.json", + "./c/ProcTHOR-Val-925.scene_instance.json", + "./c/ProcTHOR-Val-724.scene_instance.json", + "./c/ProcTHOR-Val-455.scene_instance.json", + "./c/ProcTHOR-Val-29.scene_instance.json", + "./c/ProcTHOR-Val-919.scene_instance.json", + "./c/ProcTHOR-Val-238.scene_instance.json", + "./c/ProcTHOR-Val-252.scene_instance.json", + "./c/ProcTHOR-Val-199.scene_instance.json", + "./c/ProcTHOR-Val-835.scene_instance.json", + "./c/ProcTHOR-Val-545.scene_instance.json", + "./c/ProcTHOR-Val-531.scene_instance.json", + "./c/ProcTHOR-Val-484.scene_instance.json", + "./c/ProcTHOR-Val-804.scene_instance.json", + "./c/ProcTHOR-Val-702.scene_instance.json", + "./c/ProcTHOR-Val-461.scene_instance.json", + "./c/ProcTHOR-Val-754.scene_instance.json", + "./c/ProcTHOR-Val-652.scene_instance.json", + "./c/ProcTHOR-Val-311.scene_instance.json", + "./c/ProcTHOR-Val-177.scene_instance.json", + "./c/ProcTHOR-Val-434.scene_instance.json", + "./c/ProcTHOR-Val-95.scene_instance.json", + "./c/ProcTHOR-Val-335.scene_instance.json", + "./c/ProcTHOR-Val-539.scene_instance.json", + "./c/ProcTHOR-Val-86.scene_instance.json", + "./c/ProcTHOR-Val-429.scene_instance.json", + "./c/ProcTHOR-Val-397.scene_instance.json", + "./c/ProcTHOR-Val-220.scene_instance.json", + "./c/ProcTHOR-Val-225.scene_instance.json", + "./c/ProcTHOR-Val-810.scene_instance.json", + "./c/ProcTHOR-Val-618.scene_instance.json", + "./c/ProcTHOR-Val-308.scene_instance.json", + "./c/ProcTHOR-Val-860.scene_instance.json", + "./c/ProcTHOR-Val-568.scene_instance.json", + "./c/ProcTHOR-Val-131.scene_instance.json", + "./c/ProcTHOR-Val-651.scene_instance.json", + "./c/ProcTHOR-Val-488.scene_instance.json", + "./c/ProcTHOR-Val-246.scene_instance.json", + "./c/ProcTHOR-Val-688.scene_instance.json", + "./c/ProcTHOR-Val-586.scene_instance.json", + "./c/ProcTHOR-Val-41.scene_instance.json", + "./c/ProcTHOR-Val-641.scene_instance.json", + "./c/ProcTHOR-Val-50.scene_instance.json", + "./c/ProcTHOR-Val-789.scene_instance.json", + "./c/ProcTHOR-Val-636.scene_instance.json", + "./c/ProcTHOR-Val-470.scene_instance.json", + "./c/ProcTHOR-Val-175.scene_instance.json", + "./c/ProcTHOR-Val-349.scene_instance.json", + "./c/ProcTHOR-Val-471.scene_instance.json", + "./c/ProcTHOR-Val-799.scene_instance.json", + "./c/ProcTHOR-Val-787.scene_instance.json", + "./c/ProcTHOR-Val-791.scene_instance.json", + "./c/ProcTHOR-Val-700.scene_instance.json", + "./c/ProcTHOR-Val-795.scene_instance.json", + "./c/ProcTHOR-Val-106.scene_instance.json", + "./c/ProcTHOR-Val-834.scene_instance.json", + "./c/ProcTHOR-Val-208.scene_instance.json", + "./c/ProcTHOR-Val-438.scene_instance.json", + "./c/ProcTHOR-Val-244.scene_instance.json", + "./c/ProcTHOR-Val-423.scene_instance.json", + "./c/ProcTHOR-Val-890.scene_instance.json", + "./c/ProcTHOR-Val-10.scene_instance.json", + "./c/ProcTHOR-Val-255.scene_instance.json", + "./c/ProcTHOR-Val-879.scene_instance.json", + "./c/ProcTHOR-Val-292.scene_instance.json", + "./c/ProcTHOR-Val-463.scene_instance.json", + "./c/ProcTHOR-Val-689.scene_instance.json", + "./c/ProcTHOR-Val-644.scene_instance.json", + "./c/ProcTHOR-Val-625.scene_instance.json", + "./c/ProcTHOR-Val-150.scene_instance.json", + "./c/ProcTHOR-Val-848.scene_instance.json", + "./c/ProcTHOR-Val-841.scene_instance.json", + "./c/ProcTHOR-Val-111.scene_instance.json", + "./c/ProcTHOR-Val-472.scene_instance.json", + "./c/ProcTHOR-Val-216.scene_instance.json", + "./c/ProcTHOR-Val-948.scene_instance.json", + "./c/ProcTHOR-Val-137.scene_instance.json", + "./c/ProcTHOR-Val-83.scene_instance.json", + "./c/ProcTHOR-Val-133.scene_instance.json", + "./c/ProcTHOR-Val-203.scene_instance.json", + "./c/ProcTHOR-Val-857.scene_instance.json", + "./c/ProcTHOR-Val-209.scene_instance.json", + "./c/ProcTHOR-Val-788.scene_instance.json", + "./c/ProcTHOR-Val-14.scene_instance.json", + "./c/ProcTHOR-Val-3.scene_instance.json", + "./c/ProcTHOR-Val-215.scene_instance.json", + "./c/ProcTHOR-Val-151.scene_instance.json", + "./c/ProcTHOR-Val-544.scene_instance.json", + "./c/ProcTHOR-Val-187.scene_instance.json", + "./c/ProcTHOR-Val-608.scene_instance.json", + "./c/ProcTHOR-Val-326.scene_instance.json", + "./c/ProcTHOR-Val-656.scene_instance.json", + "./c/ProcTHOR-Val-110.scene_instance.json", + "./c/ProcTHOR-Val-219.scene_instance.json", + "./c/ProcTHOR-Val-947.scene_instance.json", + "./c/ProcTHOR-Val-965.scene_instance.json", + "./c/ProcTHOR-Val-497.scene_instance.json", + "./c/ProcTHOR-Val-416.scene_instance.json", + "./c/ProcTHOR-Val-758.scene_instance.json", + "./c/ProcTHOR-Val-640.scene_instance.json", + "./c/ProcTHOR-Val-837.scene_instance.json", + "./c/ProcTHOR-Val-481.scene_instance.json", + "./c/ProcTHOR-Val-80.scene_instance.json", + "./c/ProcTHOR-Val-265.scene_instance.json", + "./c/ProcTHOR-Val-202.scene_instance.json", + "./c/ProcTHOR-Val-944.scene_instance.json", + "./c/ProcTHOR-Val-981.scene_instance.json", + "./c/ProcTHOR-Val-714.scene_instance.json", + "./c/ProcTHOR-Val-631.scene_instance.json", + "./c/ProcTHOR-Val-237.scene_instance.json", + "./c/ProcTHOR-Val-176.scene_instance.json", + "./c/ProcTHOR-Val-188.scene_instance.json", + "./c/ProcTHOR-Val-103.scene_instance.json", + "./c/ProcTHOR-Val-82.scene_instance.json", + "./c/ProcTHOR-Val-446.scene_instance.json", + "./c/ProcTHOR-Val-850.scene_instance.json", + "./c/ProcTHOR-Val-838.scene_instance.json", + "./c/ProcTHOR-Val-123.scene_instance.json", + "./c/ProcTHOR-Val-437.scene_instance.json", + "./c/ProcTHOR-Val-405.scene_instance.json", + "./c/ProcTHOR-Val-579.scene_instance.json", + "./c/ProcTHOR-Val-512.scene_instance.json", + "./c/ProcTHOR-Val-598.scene_instance.json", + "./c/ProcTHOR-Val-843.scene_instance.json", + "./c/ProcTHOR-Val-902.scene_instance.json", + "./c/ProcTHOR-Val-482.scene_instance.json", + "./c/ProcTHOR-Val-969.scene_instance.json", + "./c/ProcTHOR-Val-533.scene_instance.json", + "./c/ProcTHOR-Val-953.scene_instance.json", + "./c/ProcTHOR-Val-783.scene_instance.json", + "./c/ProcTHOR-Val-465.scene_instance.json", + "./c/ProcTHOR-Val-136.scene_instance.json", + "./c/ProcTHOR-Val-247.scene_instance.json", + "./c/ProcTHOR-Val-337.scene_instance.json", + "./c/ProcTHOR-Val-936.scene_instance.json", + "./c/ProcTHOR-Val-921.scene_instance.json", + "./c/ProcTHOR-Val-427.scene_instance.json", + "./c/ProcTHOR-Val-299.scene_instance.json", + "./c/ProcTHOR-Val-211.scene_instance.json", + "./c/ProcTHOR-Val-612.scene_instance.json", + "./c/ProcTHOR-Val-370.scene_instance.json", + "./c/ProcTHOR-Val-441.scene_instance.json", + "./c/ProcTHOR-Val-364.scene_instance.json", + "./c/ProcTHOR-Val-108.scene_instance.json", + "./c/ProcTHOR-Val-0.scene_instance.json", + "./c/ProcTHOR-Val-927.scene_instance.json", + "./c/ProcTHOR-Val-498.scene_instance.json", + "./c/ProcTHOR-Val-829.scene_instance.json", + "./c/ProcTHOR-Val-604.scene_instance.json", + "./c/ProcTHOR-Val-671.scene_instance.json", + "./c/ProcTHOR-Val-756.scene_instance.json", + "./c/ProcTHOR-Val-571.scene_instance.json", + "./c/ProcTHOR-Val-596.scene_instance.json", + "./c/ProcTHOR-Val-978.scene_instance.json", + "./c/ProcTHOR-Val-836.scene_instance.json", + "./c/ProcTHOR-Val-485.scene_instance.json", + "./c/ProcTHOR-Val-991.scene_instance.json", + "./c/ProcTHOR-Val-431.scene_instance.json", + "./c/ProcTHOR-Val-13.scene_instance.json", + "./c/ProcTHOR-Val-305.scene_instance.json", + "./c/ProcTHOR-Val-962.scene_instance.json", + "./c/ProcTHOR-Val-415.scene_instance.json", + "./c/ProcTHOR-Val-538.scene_instance.json", + "./c/ProcTHOR-Val-33.scene_instance.json", + "./c/ProcTHOR-Val-195.scene_instance.json", + "./c/ProcTHOR-Val-937.scene_instance.json", + "./c/ProcTHOR-Val-69.scene_instance.json", + "./c/ProcTHOR-Val-45.scene_instance.json", + "./c/ProcTHOR-Val-173.scene_instance.json", + "./c/ProcTHOR-Val-37.scene_instance.json", + "./c/ProcTHOR-Val-153.scene_instance.json", + "./c/ProcTHOR-Val-279.scene_instance.json", + "./c/ProcTHOR-Val-251.scene_instance.json", + "./c/ProcTHOR-Val-250.scene_instance.json", + "./c/ProcTHOR-Val-345.scene_instance.json", + "./c/ProcTHOR-Val-85.scene_instance.json", + "./c/ProcTHOR-Val-529.scene_instance.json", + "./c/ProcTHOR-Val-673.scene_instance.json", + "./c/ProcTHOR-Val-459.scene_instance.json", + "./c/ProcTHOR-Val-524.scene_instance.json", + "./c/ProcTHOR-Val-593.scene_instance.json", + "./c/ProcTHOR-Val-307.scene_instance.json", + "./c/ProcTHOR-Val-985.scene_instance.json", + "./c/ProcTHOR-Val-79.scene_instance.json", + "./c/ProcTHOR-Val-258.scene_instance.json", + "./c/ProcTHOR-Val-900.scene_instance.json", + "./c/ProcTHOR-Val-525.scene_instance.json", + "./c/ProcTHOR-Val-706.scene_instance.json", + "./c/ProcTHOR-Val-738.scene_instance.json", + "./c/ProcTHOR-Val-869.scene_instance.json", + "./c/ProcTHOR-Val-294.scene_instance.json", + "./c/ProcTHOR-Val-191.scene_instance.json", + "./c/ProcTHOR-Val-505.scene_instance.json", + "./c/ProcTHOR-Val-745.scene_instance.json", + "./c/ProcTHOR-Val-351.scene_instance.json", + "./c/ProcTHOR-Val-716.scene_instance.json", + "./c/ProcTHOR-Val-534.scene_instance.json", + "./c/ProcTHOR-Val-584.scene_instance.json", + "./c/ProcTHOR-Val-877.scene_instance.json", + "./c/ProcTHOR-Val-503.scene_instance.json", + "./c/ProcTHOR-Val-681.scene_instance.json", + "./c/ProcTHOR-Val-602.scene_instance.json", + "./c/ProcTHOR-Val-223.scene_instance.json", + "./c/ProcTHOR-Val-46.scene_instance.json", + "./c/ProcTHOR-Val-340.scene_instance.json", + "./c/ProcTHOR-Val-9.scene_instance.json", + "./c/ProcTHOR-Val-104.scene_instance.json", + "./c/ProcTHOR-Val-489.scene_instance.json", + "./c/ProcTHOR-Val-172.scene_instance.json", + "./c/ProcTHOR-Val-603.scene_instance.json", + "./c/ProcTHOR-Val-253.scene_instance.json", + "./c/ProcTHOR-Val-630.scene_instance.json", + "./c/ProcTHOR-Val-961.scene_instance.json", + "./c/ProcTHOR-Val-649.scene_instance.json", + "./c/ProcTHOR-Val-727.scene_instance.json", + "./c/ProcTHOR-Val-491.scene_instance.json", + "./c/ProcTHOR-Val-975.scene_instance.json", + "./c/ProcTHOR-Val-872.scene_instance.json", + "./c/ProcTHOR-Val-814.scene_instance.json", + "./c/ProcTHOR-Val-891.scene_instance.json", + "./c/ProcTHOR-Val-831.scene_instance.json", + "./c/ProcTHOR-Val-506.scene_instance.json", + "./c/ProcTHOR-Val-23.scene_instance.json", + "./c/ProcTHOR-Val-508.scene_instance.json", + "./c/ProcTHOR-Val-426.scene_instance.json", + "./c/ProcTHOR-Val-819.scene_instance.json", + "./c/ProcTHOR-Val-207.scene_instance.json", + "./c/ProcTHOR-Val-778.scene_instance.json", + "./c/ProcTHOR-Val-742.scene_instance.json", + "./c/ProcTHOR-Val-374.scene_instance.json", + "./c/ProcTHOR-Val-690.scene_instance.json", + "./c/ProcTHOR-Val-523.scene_instance.json", + "./c/ProcTHOR-Val-994.scene_instance.json", + "./c/ProcTHOR-Val-135.scene_instance.json", + "./c/ProcTHOR-Val-166.scene_instance.json", + "./c/ProcTHOR-Val-281.scene_instance.json", + "./c/ProcTHOR-Val-198.scene_instance.json", + "./c/ProcTHOR-Val-334.scene_instance.json", + "./c/ProcTHOR-Val-411.scene_instance.json", + "./c/ProcTHOR-Val-839.scene_instance.json", + "./c/ProcTHOR-Val-932.scene_instance.json", + "./c/ProcTHOR-Val-580.scene_instance.json", + "./c/ProcTHOR-Val-464.scene_instance.json", + "./c/ProcTHOR-Val-723.scene_instance.json", + "./c/ProcTHOR-Val-121.scene_instance.json", + "./c/ProcTHOR-Val-447.scene_instance.json", + "./c/ProcTHOR-Val-820.scene_instance.json", + "./c/ProcTHOR-Val-314.scene_instance.json", + "./c/ProcTHOR-Val-634.scene_instance.json", + "./c/ProcTHOR-Val-269.scene_instance.json", + "./c/ProcTHOR-Val-697.scene_instance.json", + "./c/ProcTHOR-Val-275.scene_instance.json", + "./c/ProcTHOR-Val-624.scene_instance.json", + "./c/ProcTHOR-Val-160.scene_instance.json", + "./c/ProcTHOR-Val-165.scene_instance.json", + "./c/ProcTHOR-Val-623.scene_instance.json", + "./c/ProcTHOR-Val-400.scene_instance.json", + "./c/ProcTHOR-Val-792.scene_instance.json", + "./c/ProcTHOR-Val-972.scene_instance.json", + "./c/ProcTHOR-Val-324.scene_instance.json", + "./c/ProcTHOR-Val-527.scene_instance.json", + "./c/ProcTHOR-Val-616.scene_instance.json", + "./c/ProcTHOR-Val-514.scene_instance.json", + "./c/ProcTHOR-Val-638.scene_instance.json", + "./c/ProcTHOR-Val-668.scene_instance.json", + "./c/ProcTHOR-Val-600.scene_instance.json", + "./c/ProcTHOR-Val-56.scene_instance.json", + "./c/ProcTHOR-Val-893.scene_instance.json", + "./c/ProcTHOR-Val-913.scene_instance.json", + "./c/ProcTHOR-Val-5.scene_instance.json", + "./c/ProcTHOR-Val-556.scene_instance.json", + "./c/ProcTHOR-Val-78.scene_instance.json", + "./c/ProcTHOR-Val-615.scene_instance.json", + "./c/ProcTHOR-Val-42.scene_instance.json", + "./c/ProcTHOR-Val-318.scene_instance.json", + "./c/ProcTHOR-Val-563.scene_instance.json", + "./c/ProcTHOR-Val-4.scene_instance.json", + "./c/ProcTHOR-Val-767.scene_instance.json", + "./c/ProcTHOR-Val-194.scene_instance.json", + "./c/ProcTHOR-Val-785.scene_instance.json", + "./c/ProcTHOR-Val-653.scene_instance.json", + "./c/ProcTHOR-Val-217.scene_instance.json", + "./c/ProcTHOR-Val-830.scene_instance.json", + "./c/ProcTHOR-Val-790.scene_instance.json", + "./c/ProcTHOR-Val-912.scene_instance.json", + "./c/ProcTHOR-Val-582.scene_instance.json", + "./c/ProcTHOR-Val-179.scene_instance.json", + "./c/ProcTHOR-Val-407.scene_instance.json", + "./c/ProcTHOR-Val-691.scene_instance.json", + "./c/ProcTHOR-Val-777.scene_instance.json", + "./c/ProcTHOR-Val-212.scene_instance.json", + "./c/ProcTHOR-Val-315.scene_instance.json", + "./c/ProcTHOR-Val-114.scene_instance.json", + "./c/ProcTHOR-Val-221.scene_instance.json", + "./c/ProcTHOR-Val-7.scene_instance.json", + "./c/ProcTHOR-Val-599.scene_instance.json", + "./c/ProcTHOR-Val-847.scene_instance.json", + "./c/ProcTHOR-Val-517.scene_instance.json", + "./c/ProcTHOR-Val-40.scene_instance.json", + "./c/ProcTHOR-Val-567.scene_instance.json", + "./c/ProcTHOR-Val-802.scene_instance.json", + "./c/ProcTHOR-Val-399.scene_instance.json", + "./c/ProcTHOR-Val-266.scene_instance.json", + "./c/ProcTHOR-Val-811.scene_instance.json", + "./c/ProcTHOR-Val-109.scene_instance.json", + "./c/ProcTHOR-Val-249.scene_instance.json", + "./c/ProcTHOR-Val-322.scene_instance.json", + "./c/ProcTHOR-Val-862.scene_instance.json", + "./c/ProcTHOR-Val-510.scene_instance.json", + "./c/ProcTHOR-Val-801.scene_instance.json", + "./c/ProcTHOR-Val-662.scene_instance.json", + "./c/ProcTHOR-Val-433.scene_instance.json", + "./c/ProcTHOR-Val-448.scene_instance.json", + "./c/ProcTHOR-Val-621.scene_instance.json", + "./c/ProcTHOR-Val-495.scene_instance.json", + "./c/ProcTHOR-Val-466.scene_instance.json", + "./c/ProcTHOR-Val-595.scene_instance.json", + "./c/ProcTHOR-Val-458.scene_instance.json", + "./c/ProcTHOR-Val-157.scene_instance.json", + "./c/ProcTHOR-Val-583.scene_instance.json", + "./c/ProcTHOR-Val-982.scene_instance.json", + "./c/ProcTHOR-Val-232.scene_instance.json", + "./c/ProcTHOR-Val-259.scene_instance.json", + "./c/ProcTHOR-Val-230.scene_instance.json", + "./c/ProcTHOR-Val-813.scene_instance.json", + "./c/ProcTHOR-Val-635.scene_instance.json", + "./c/ProcTHOR-Val-361.scene_instance.json", + "./c/ProcTHOR-Val-356.scene_instance.json", + "./c/ProcTHOR-Val-490.scene_instance.json", + "./c/ProcTHOR-Val-243.scene_instance.json", + "./c/ProcTHOR-Val-928.scene_instance.json", + "./c/ProcTHOR-Val-277.scene_instance.json" + ] + +} \ No newline at end of file diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/RoboTHOR.json b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/RoboTHOR.json new file mode 100644 index 0000000000000000000000000000000000000000..c9e458a6bf6cdee029728badfe5d0d47a51106c9 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/RoboTHOR.json @@ -0,0 +1,80 @@ +{ + "scenes": [ + "./FloorPlan_Train3_3.scene_instance.json", + "./FloorPlan_Train11_2.scene_instance.json", + "./FloorPlan_Train5_2.scene_instance.json", + "./FloorPlan_Val1_2.scene_instance.json", + "./FloorPlan_Train1_4.scene_instance.json", + "./FloorPlan_Train11_3.scene_instance.json", + "./FloorPlan_Train2_5.scene_instance.json", + "./FloorPlan_Val2_4.scene_instance.json", + "./FloorPlan_Train3_5.scene_instance.json", + "./FloorPlan_Train12_5.scene_instance.json", + "./FloorPlan_Train5_3.scene_instance.json", + "./FloorPlan_Train12_2.scene_instance.json", + "./FloorPlan_Train4_3.scene_instance.json", + "./FloorPlan_Train1_3.scene_instance.json", + "./FloorPlan_Val1_1.scene_instance.json", + "./FloorPlan_Train1_1.scene_instance.json", + "./FloorPlan_Train5_1.scene_instance.json", + "./FloorPlan_Train5_5.scene_instance.json", + "./FloorPlan_Train3_2.scene_instance.json", + "./FloorPlan_Train8_2.scene_instance.json", + "./FloorPlan_Val3_2.scene_instance.json", + "./FloorPlan_Train6_3.scene_instance.json", + "./FloorPlan_Train9_5.scene_instance.json", + "./FloorPlan_Val1_4.scene_instance.json", + "./FloorPlan_Train10_1.scene_instance.json", + "./FloorPlan_Train2_1.scene_instance.json", + "./FloorPlan_Train11_4.scene_instance.json", + "./FloorPlan_Train8_5.scene_instance.json", + "./FloorPlan_Train7_3.scene_instance.json", + "./FloorPlan_Train9_4.scene_instance.json", + "./FloorPlan_Train3_1.scene_instance.json", + "./FloorPlan_Train6_2.scene_instance.json", + "./FloorPlan_Train4_5.scene_instance.json", + "./FloorPlan_Train4_2.scene_instance.json", + "./FloorPlan_Train9_3.scene_instance.json", + "./FloorPlan_Val1_3.scene_instance.json", + "./FloorPlan_Train4_1.scene_instance.json", + "./FloorPlan_Train12_4.scene_instance.json", + "./FloorPlan_Train9_1.scene_instance.json", + "./FloorPlan_Train8_1.scene_instance.json", + "./FloorPlan_Val3_5.scene_instance.json", + "./FloorPlan_Val2_2.scene_instance.json", + "./FloorPlan_Train10_2.scene_instance.json", + "./FloorPlan_Train6_5.scene_instance.json", + "./FloorPlan_Val2_1.scene_instance.json", + "./FloorPlan_Train12_3.scene_instance.json", + "./FloorPlan_Train7_4.scene_instance.json", + "./FloorPlan_Train2_4.scene_instance.json", + "./FloorPlan_Train3_4.scene_instance.json", + "./FloorPlan_Train9_2.scene_instance.json", + "./FloorPlan_Train7_5.scene_instance.json", + "./FloorPlan_Train10_3.scene_instance.json", + "./FloorPlan_Train2_2.scene_instance.json", + "./FloorPlan_Train8_3.scene_instance.json", + "./FloorPlan_Train1_2.scene_instance.json", + "./FloorPlan_Val2_5.scene_instance.json", + "./FloorPlan_Train7_2.scene_instance.json", + "./FloorPlan_Train10_4.scene_instance.json", + "./FloorPlan_Train8_4.scene_instance.json", + "./FloorPlan_Train2_3.scene_instance.json", + "./FloorPlan_Val1_5.scene_instance.json", + "./FloorPlan_Train4_4.scene_instance.json", + "./FloorPlan_Train1_5.scene_instance.json", + "./FloorPlan_Val3_4.scene_instance.json", + "./FloorPlan_Train6_4.scene_instance.json", + "./FloorPlan_Val2_3.scene_instance.json", + "./FloorPlan_Train7_1.scene_instance.json", + "./FloorPlan_Train11_5.scene_instance.json", + "./FloorPlan_Train10_5.scene_instance.json", + "./FloorPlan_Train6_1.scene_instance.json", + "./FloorPlan_Train11_1.scene_instance.json", + "./FloorPlan_Val3_3.scene_instance.json", + "./FloorPlan_Val3_1.scene_instance.json", + "./FloorPlan_Train5_4.scene_instance.json", + "./FloorPlan_Train12_1.scene_instance.json" + ] + +} \ No newline at end of file diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/iTHOR.json b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/iTHOR.json new file mode 100644 index 0000000000000000000000000000000000000000..d148e93cc688269c32e03cdea93ba03e8e948ffe --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/metadata/iTHOR.json @@ -0,0 +1,155 @@ +{ + "scenes": [ + "./FloorPlan7_physics.scene_instance.json", + "./FloorPlan3_physics.scene_instance.json", + "./FloorPlan421_physics.scene_instance.json", + "./FloorPlan412_physics.scene_instance.json", + "./FloorPlan203_physics.scene_instance.json", + "./FloorPlan526_physics.scene_instance.json", + "./FloorPlan324_physics.scene_instance.json", + "./FloorPlan521_physics.scene_instance.json", + "./FloorPlan504_physics.scene_instance.json", + "./FloorPlan429_physics.scene_instance.json", + "./FloorPlan227_physics.scene_instance.json", + "./FloorPlan312_physics.scene_instance.json", + "./FloorPlan330_physics.scene_instance.json", + "./FloorPlan417_physics.scene_instance.json", + "./FloorPlan20_physics.scene_instance.json", + "./FloorPlan403_physics.scene_instance.json", + "./FloorPlan407_physics.scene_instance.json", + "./FloorPlan214_physics.scene_instance.json", + "./FloorPlan505_physics.scene_instance.json", + "./FloorPlan405_physics.scene_instance.json", + "./FloorPlan517_physics.scene_instance.json", + "./FloorPlan211_physics.scene_instance.json", + "./FloorPlan28_physics.scene_instance.json", + "./FloorPlan320_physics.scene_instance.json", + "./FloorPlan314_physics.scene_instance.json", + "./FloorPlan415_physics.scene_instance.json", + "./FloorPlan301_physics.scene_instance.json", + "./FloorPlan221_physics.scene_instance.json", + "./FloorPlan516_physics.scene_instance.json", + "./FloorPlan518_physics.scene_instance.json", + "./FloorPlan10_physics.scene_instance.json", + "./FloorPlan307_physics.scene_instance.json", + "./FloorPlan17_physics.scene_instance.json", + "./FloorPlan222_physics.scene_instance.json", + "./FloorPlan30_physics.scene_instance.json", + "./FloorPlan522_physics.scene_instance.json", + "./FloorPlan523_physics.scene_instance.json", + "./FloorPlan201_physics.scene_instance.json", + "./FloorPlan12_physics.scene_instance.json", + "./FloorPlan513_physics.scene_instance.json", + "./FloorPlan416_physics.scene_instance.json", + "./FloorPlan230_physics.scene_instance.json", + "./FloorPlan503_physics.scene_instance.json", + "./FloorPlan14_physics.scene_instance.json", + "./FloorPlan217_physics.scene_instance.json", + "./FloorPlan502_physics.scene_instance.json", + "./FloorPlan228_physics.scene_instance.json", + "./FloorPlan209_physics.scene_instance.json", + "./FloorPlan323_physics.scene_instance.json", + "./FloorPlan204_physics.scene_instance.json", + "./FloorPlan4_physics.scene_instance.json", + "./FloorPlan514_physics.scene_instance.json", + "./FloorPlan529_physics.scene_instance.json", + "./FloorPlan319_physics.scene_instance.json", + "./FloorPlan22_physics.scene_instance.json", + "./FloorPlan207_physics.scene_instance.json", + "./FloorPlan515_physics.scene_instance.json", + "./FloorPlan419_physics.scene_instance.json", + "./FloorPlan304_physics.scene_instance.json", + "./FloorPlan507_physics.scene_instance.json", + "./FloorPlan408_physics.scene_instance.json", + "./FloorPlan422_physics.scene_instance.json", + "./FloorPlan309_physics.scene_instance.json", + "./FloorPlan519_physics.scene_instance.json", + "./FloorPlan428_physics.scene_instance.json", + "./FloorPlan302_physics.scene_instance.json", + "./FloorPlan410_physics.scene_instance.json", + "./FloorPlan226_physics.scene_instance.json", + "./FloorPlan1_physics.scene_instance.json", + "./FloorPlan18_physics.scene_instance.json", + "./FloorPlan325_physics.scene_instance.json", + "./FloorPlan5_physics.scene_instance.json", + "./FloorPlan224_physics.scene_instance.json", + "./FloorPlan24_physics.scene_instance.json", + "./FloorPlan430_physics.scene_instance.json", + "./FloorPlan509_physics.scene_instance.json", + "./FloorPlan426_physics.scene_instance.json", + "./FloorPlan327_physics.scene_instance.json", + "./FloorPlan13_physics.scene_instance.json", + "./FloorPlan223_physics.scene_instance.json", + "./FloorPlan303_physics.scene_instance.json", + "./FloorPlan524_physics.scene_instance.json", + "./FloorPlan418_physics.scene_instance.json", + "./FloorPlan19_physics.scene_instance.json", + "./FloorPlan220_physics.scene_instance.json", + "./FloorPlan322_physics.scene_instance.json", + "./FloorPlan218_physics.scene_instance.json", + "./FloorPlan420_physics.scene_instance.json", + "./FloorPlan229_physics.scene_instance.json", + "./FloorPlan225_physics.scene_instance.json", + "./FloorPlan21_physics.scene_instance.json", + "./FloorPlan29_physics.scene_instance.json", + "./FloorPlan511_physics.scene_instance.json", + "./FloorPlan525_physics.scene_instance.json", + "./FloorPlan508_physics.scene_instance.json", + "./FloorPlan213_physics.scene_instance.json", + "./FloorPlan329_physics.scene_instance.json", + "./FloorPlan23_physics.scene_instance.json", + "./FloorPlan530_physics.scene_instance.json", + "./FloorPlan402_physics.scene_instance.json", + "./FloorPlan413_physics.scene_instance.json", + "./FloorPlan321_physics.scene_instance.json", + "./FloorPlan310_physics.scene_instance.json", + "./FloorPlan15_physics.scene_instance.json", + "./FloorPlan427_physics.scene_instance.json", + "./FloorPlan208_physics.scene_instance.json", + "./FloorPlan308_physics.scene_instance.json", + "./FloorPlan306_physics.scene_instance.json", + "./FloorPlan315_physics.scene_instance.json", + "./FloorPlan202_physics.scene_instance.json", + "./FloorPlan326_physics.scene_instance.json", + "./FloorPlan425_physics.scene_instance.json", + "./FloorPlan506_physics.scene_instance.json", + "./FloorPlan26_physics.scene_instance.json", + "./FloorPlan520_physics.scene_instance.json", + "./FloorPlan6_physics.scene_instance.json", + "./FloorPlan212_physics.scene_instance.json", + "./FloorPlan16_physics.scene_instance.json", + "./FloorPlan8_physics.scene_instance.json", + "./FloorPlan414_physics.scene_instance.json", + "./FloorPlan406_physics.scene_instance.json", + "./FloorPlan313_physics.scene_instance.json", + "./FloorPlan311_physics.scene_instance.json", + "./FloorPlan527_physics.scene_instance.json", + "./FloorPlan318_physics.scene_instance.json", + "./FloorPlan328_physics.scene_instance.json", + "./FloorPlan401_physics.scene_instance.json", + "./FloorPlan528_physics.scene_instance.json", + "./FloorPlan423_physics.scene_instance.json", + "./FloorPlan27_physics.scene_instance.json", + "./FloorPlan404_physics.scene_instance.json", + "./FloorPlan11_physics.scene_instance.json", + "./FloorPlan215_physics.scene_instance.json", + "./FloorPlan210_physics.scene_instance.json", + "./FloorPlan317_physics.scene_instance.json", + "./FloorPlan510_physics.scene_instance.json", + "./FloorPlan205_physics.scene_instance.json", + "./FloorPlan219_physics.scene_instance.json", + "./FloorPlan216_physics.scene_instance.json", + "./FloorPlan25_physics.scene_instance.json", + "./FloorPlan9_physics.scene_instance.json", + "./FloorPlan501_physics.scene_instance.json", + "./FloorPlan512_physics.scene_instance.json", + "./FloorPlan424_physics.scene_instance.json", + "./FloorPlan305_physics.scene_instance.json", + "./FloorPlan411_physics.scene_instance.json", + "./FloorPlan316_physics.scene_instance.json", + "./FloorPlan206_physics.scene_instance.json", + "./FloorPlan409_physics.scene_instance.json", + "./FloorPlan2_physics.scene_instance.json" + ] + +} \ No newline at end of file diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/scene_builder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/scene_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..89b10b11263a435a6846b7606caf8b40196648f0 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/scene_builder.py @@ -0,0 +1,296 @@ +""" +SceneBuilder for the AI2Thor scenes, using configurations and assets stored in https://huggingface.co/datasets/hssd/ai2thor-hab + +""" + +import json +import os.path as osp +from pathlib import Path +from typing import Dict, List, Tuple, Union + +import numpy as np +import sapien +import sapien.core as sapien +import sapien.physx as physx +import torch +import transforms3d +from tqdm import tqdm + +from mani_skill import ASSET_DIR +from mani_skill.agents.robots.fetch import ( + FETCH_BASE_COLLISION_BIT, + FETCH_WHEELS_COLLISION_BIT, + Fetch, +) +from mani_skill.envs.scene import ManiSkillScene +from mani_skill.utils.scene_builder import SceneBuilder +from mani_skill.utils.structs import Actor, Articulation, Pose + +from .constants import SCENE_SOURCE_TO_DATASET, AI2BuildConfig, load_ai2thor_metadata + +DATASET_CONFIG_DIR = osp.join(osp.dirname(__file__), "metadata") + +ALL_SCENE_CONFIGS = ( + dict() +) # cached results mapping scene dataset ID to a list of scene configurations + +OBJECT_SEMANTIC_ID_MAPPING, SEMANTIC_ID_OBJECT_MAPPING, MOVEABLE_OBJECT_IDS = ( + None, + None, + None, +) + +WORKING_OBJS = [ + "apple", + "potato", + "tomato", + "lettuce", + "soap", + "sponge", + "plate", + "book", +] +FETCH_BUILD_CONFIG_IDX_TO_START_POS = { + 0: (-3, 0), + 1: (-2, -2), + 2: (0, 0), + 3: (-3.5, 0), + 4: (0, -2), + 5: (-1, 1.5), + 6: (1, -0.5), + 7: (3.25, 1), + 8: (1, 2), + 9: (1, 1), +} + + +class AI2THORBaseSceneBuilder(SceneBuilder): + """ + The Base AI2THOR scene builder class. Subclasses + """ + + scene_dataset: str + + def __init__(self, env, robot_init_qpos_noise=0.02): + super().__init__(env, robot_init_qpos_noise=robot_init_qpos_noise) + global OBJECT_SEMANTIC_ID_MAPPING, SEMANTIC_ID_OBJECT_MAPPING, MOVEABLE_OBJECT_IDS + ( + OBJECT_SEMANTIC_ID_MAPPING, + SEMANTIC_ID_OBJECT_MAPPING, + MOVEABLE_OBJECT_IDS, + ) = load_ai2thor_metadata() + self.build_configs: List[AI2BuildConfig] = [] + if self.scene_dataset not in ALL_SCENE_CONFIGS: + dataset_path = SCENE_SOURCE_TO_DATASET[self.scene_dataset].metadata_path + with open(osp.join(DATASET_CONFIG_DIR, dataset_path)) as f: + build_config_jsons = json.load(f)["scenes"] + self.build_configs += [ + AI2BuildConfig(config_file=build_config_json, source=self.scene_dataset) + for build_config_json in build_config_jsons + ] + ALL_SCENE_CONFIGS[self.scene_dataset] = self.build_configs + else: + self.build_configs = ALL_SCENE_CONFIGS[self.scene_dataset] + + self._navigable_positions = [None] * len(self.build_configs) + self.build_config_idxs: List[int] = None + + def _should_be_static(self, template_name: str): + object_config_json = ( + Path(ASSET_DIR) + / "scene_datasets/ai2thor/ai2thorhab-uncompressed/configs" + / f"{template_name}.object_config.json" + ) + with open(object_config_json, "r") as f: + object_config_json = json.load(f) + semantic_id = object_config_json["semantic_id"] + object_category = SEMANTIC_ID_OBJECT_MAPPING[semantic_id] + return object_category not in MOVEABLE_OBJECT_IDS + + # TODO (arth): figure out coacd building issues (currenlty fails on > 80% objs) + def build( + self, + build_config_idxs: Union[int, List[int]], + convex_decomposition="none", + ): + # build_config_idxs is a list of integers, where the ith value is the scene idx for the ith parallel env + if isinstance(build_config_idxs, int): + build_config_idxs = [build_config_idxs] * self.env.num_envs + assert all([isinstance(bci, int) for bci in build_config_idxs]) + assert len(build_config_idxs) == self.env.num_envs + + # save scene and movable objects when building scene + self.build_config_idxs = build_config_idxs + self.scene_objects: Dict[str, Actor] = dict() + self.movable_objects: Dict[str, Actor] = dict() + self.articulations: Dict[str, Articulation] = dict() + self._default_object_poses: List[Tuple[Actor, sapien.Pose]] = [] + + # keep track of background objects separately as we need to disable mobile robot collisions + # note that we will create a merged actor using these objects to represent the bg + bgs = [None] * self.env.num_envs + + for bci in np.unique(build_config_idxs): + + env_idx = [i for i, v in enumerate(build_config_idxs) if v == bci] + unique_id = "scs-" + str(env_idx).replace(" ", "") + build_config: AI2BuildConfig = self.build_configs[bci] + + dataset = SCENE_SOURCE_TO_DATASET[build_config.source] + with open( + osp.join(dataset.dataset_path, build_config.config_file), "rb" + ) as f: + build_config_json = json.load(f) + + bg_path = str( + Path(ASSET_DIR) + / "scene_datasets/ai2thor/ai2thor-hab/assets" + / f"{build_config_json['stage_instance']['template_name']}.glb" + ) + builder = self.scene.create_actor_builder() + + bg_q = transforms3d.quaternions.axangle2quat( + np.array([1, 0, 0]), theta=np.deg2rad(90) + ) + if self.scene_dataset == "ProcTHOR": + # for some reason the scene needs to rotate around y-axis by 90 degrees for ProcTHOR scenes from hssd dataset + bg_q = transforms3d.quaternions.qmult( + bg_q, + transforms3d.quaternions.axangle2quat( + np.array([0, -1, 0]), theta=np.deg2rad(90) + ), + ) + bg_pose = sapien.Pose(q=bg_q) + builder.add_visual_from_file(bg_path, pose=bg_pose) + builder.add_nonconvex_collision_from_file(bg_path, pose=bg_pose) + builder.set_scene_idxs(env_idx) + builder.initial_pose = sapien.Pose() + bg = builder.build_static(name=f"{unique_id}_scene_background") + for i, env_num in enumerate(env_idx): + bgs[env_num] = bg._objs[i] + + global_id = 0 + for object in tqdm(build_config_json["object_instances"][:]): + model_path = ( + Path(ASSET_DIR) + / "scene_datasets/ai2thor/ai2thorhab-uncompressed/assets" + / f"{object['template_name']}.glb" + ) + actor_name = f"{object['template_name']}_{global_id}" + global_id += 1 + q = transforms3d.quaternions.axangle2quat( + np.array([1, 0, 0]), theta=np.deg2rad(90) + ) + rot_q = [ + object["rotation"][0], + object["rotation"][1], + object["rotation"][2], + object["rotation"][-1], + ] + q = transforms3d.quaternions.qmult(q, rot_q) + + builder = self.scene.create_actor_builder() + if self._should_be_static(object["template_name"]) or not any( + [name in actor_name.lower() for name in WORKING_OBJS] + ): + position = [ + object["translation"][0], + -object["translation"][2], + object["translation"][1] + 0, + ] + position = [ + object["translation"][0], + -object["translation"][2], + object["translation"][1] + 0, + ] + pose = sapien.Pose(p=position, q=q) + builder.add_visual_from_file(str(model_path)) + builder.add_nonconvex_collision_from_file(str(model_path)) + builder.initial_pose = pose + builder.set_scene_idxs(env_idx) + actor = builder.build_static(name=f"{unique_id}_{actor_name}") + else: + position = [ + object["translation"][0], + -object["translation"][2], + object["translation"][1] + 0.005, + ] + builder.add_visual_from_file(str(model_path)) + builder.add_multiple_convex_collisions_from_file( + str(model_path), + decomposition=convex_decomposition, + ) + pose = sapien.Pose(p=position, q=q) + builder.initial_pose = pose + builder.set_scene_idxs(env_idx) + actor = builder.build(name=f"{unique_id}_{actor_name}") + + self._default_object_poses.append((actor, pose)) + + for env_num in env_idx: + self.movable_objects[f"env-{env_num}_{actor_name}"] = actor + + for env_num in env_idx: + self.scene_objects[f"env-{env_num}_{actor_name}"] = actor + + if self._navigable_positions[bci] is None: + npy_fp = Path(dataset.dataset_path) / ( + Path(build_config.config_file).stem.split(".")[0] + + f".{self.env.robot_uids}.navigable_positions.npy" + ) + if npy_fp.exists(): + self._navigable_positions[bci] = np.load(npy_fp) + + self.scene.set_ambient_light([0.3, 0.3, 0.3]) + + # merge actors into one + self.bg = Actor.create_from_entities( + bgs, + scene=self.scene, + scene_idxs=torch.arange(self.env.num_envs, dtype=int), + shared_name="scene_background", + ) + + def initialize(self, env_idx): + + if self.env.robot_uids == "fetch": + agent: Fetch = self.env.agent + rest_keyframe = agent.keyframes["rest"] + agent.reset(rest_keyframe.qpos) + + agent.robot.set_pose( + Pose.create_from_pq( + p=[ + [*FETCH_BUILD_CONFIG_IDX_TO_START_POS[bci], 0.02] + for bci in self.build_config_idxs + ] + ) + ) + + # For the purposes of physical simulation, we disable collisions between the Fetch robot and the scene background + self.disable_fetch_move_collisions(self.bg) + else: + raise NotImplementedError(self.env.robot_uids) + + for obj, pose in self._default_object_poses: + obj.set_pose(pose) + if isinstance(obj, Articulation): + # note that during initialization you may only ever change poses/qpos of objects in scenes being reset + obj.set_qpos(obj.qpos[0] * 0) + + def disable_fetch_move_collisions( + self, + actor: Actor, + disable_base_collisions=False, + ): + actor.set_collision_group_bit( + group=2, bit_idx=FETCH_WHEELS_COLLISION_BIT, bit=1 + ) + if disable_base_collisions: + actor.set_collision_group_bit( + group=2, bit_idx=FETCH_BASE_COLLISION_BIT, bit=1 + ) + + @property + def navigable_positions(self) -> List[np.ndarray]: + return [self._navigable_positions[bci] for bci in self.build_config_idxs] diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/variants.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/variants.py new file mode 100644 index 0000000000000000000000000000000000000000..5b79b78602ef805db9ecda76632686ac80ac06fe --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/variants.py @@ -0,0 +1,20 @@ +from mani_skill.utils.scene_builder.registration import register_scene_builder + +from .scene_builder import AI2THORBaseSceneBuilder + + +class ProcTHORSceneBuilder(AI2THORBaseSceneBuilder): + scene_dataset = "ProcTHOR" + + +@register_scene_builder("ArchitecTHOR") +class ArchitecTHORSceneBuilder(AI2THORBaseSceneBuilder): + scene_dataset = "ArchitecTHOR" + + +class iTHORSceneBuilder(AI2THORBaseSceneBuilder): + scene_dataset = "iTHOR" + + +class RoboTHORSceneBuilder(AI2THORBaseSceneBuilder): + scene_dataset = "RoboTHOR" diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/control/planar/__pycache__/scene_builder.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/control/planar/__pycache__/scene_builder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d2c8ef8654da306a930afdcb7d9a531e65f13e0 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/control/planar/__pycache__/scene_builder.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/control/planar/scene_builder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/control/planar/scene_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..9827cd4981085a743870c55a52fbaadca517377e --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/control/planar/scene_builder.py @@ -0,0 +1,34 @@ +from typing import List + +import numpy as np +import sapien +import sapien.render +import torch +from transforms3d.euler import euler2quat + +from mani_skill.utils.building.ground import build_ground +from mani_skill.utils.scene_builder import SceneBuilder + + +class PlanarSceneBuilder(SceneBuilder): + def build(self, build_config_idxs: List[int] = None): + # ground - a strip with length along +x + self.ground = build_ground( + self.scene, + floor_width=2, + floor_length=100, + altitude=0, + xy_origin=(50 - 2, 0), + ) + + # background visual wall + self.wall = self.scene.create_actor_builder() + self.wall.add_box_visual( + half_size=(1e-3, 65, 10), + pose=sapien.Pose(p=[(50 - 2), 2, 0], q=euler2quat(0, 0, np.pi / 2)), + material=sapien.render.RenderMaterial( + base_color=np.array([0.3, 0.3, 0.3, 1]) + ), + ) + self.wall.build_static(name="wall") + self.scene_objects: List[sapien.Entity] = [self.ground, self.wall] diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..73a847ea372c77b46201394daa26ccfd4ab63d95 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/__init__.py @@ -0,0 +1 @@ +from .scene_builder import KitchenCounterSceneBuilder diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a1e8a5bad8cb33a39d6840d173446099be92d2e Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/__pycache__/scene_builder.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/__pycache__/scene_builder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8bd2dbdc43e3a9a34a0e310106e52946b3fbc60a Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/__pycache__/scene_builder.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/scene_builder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/scene_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..fa26599039955c5a454c48bc0d633171fdb14c54 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/kitchen_counter/scene_builder.py @@ -0,0 +1,40 @@ +import os.path as osp +from pathlib import Path +from typing import List + +import numpy as np +import sapien +import sapien.render +import torch +from transforms3d.euler import euler2quat + +from mani_skill.agents.multi_agent import MultiAgent +from mani_skill.agents.robots.fetch import FETCH_WHEELS_COLLISION_BIT +from mani_skill.utils.building.ground import build_ground +from mani_skill.utils.scene_builder import SceneBuilder + + +class KitchenCounterSceneBuilder(SceneBuilder): + def build(self, scale=1.0): + builder = self.scene.create_actor_builder() + model_dir = Path(osp.dirname(__file__)) / "assets" + table_model_file = str(model_dir / "kitchen_counter.glb") + table_pose = sapien.Pose(q=euler2quat(np.pi / 2, 0, np.pi)) + builder.add_nonconvex_collision_from_file( + filename=table_model_file, pose=table_pose, scale=[scale] * 3 + ) + builder.add_visual_from_file( + filename=table_model_file, scale=[scale] * 3, pose=table_pose + ) + builder.initial_pose = sapien.Pose() + table = builder.build_static(name="kitchen-counter") + + floor_width = 100 + if self.scene.parallel_in_single_scene: + floor_width = 500 + self.ground = build_ground(self.scene, floor_width=floor_width, altitude=0) + self.table = table + self.scene_objects: List[sapien.Entity] = [self.table, self.ground] + + def initialize(self, env_idx: torch.Tensor): + pass diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/registration.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/registration.py new file mode 100644 index 0000000000000000000000000000000000000000..ce292f479c65b45be46084a15c62bd2bb100963e --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/registration.py @@ -0,0 +1,43 @@ +from dataclasses import dataclass +from typing import Dict + +from mani_skill import logger +from mani_skill.agents.base_agent import BaseAgent +from mani_skill.utils.scene_builder import scene_builder + + +@dataclass +class SceneBuilderSpec: + """Scene builder specifications. At the moment it is a simple wrapper around the scene_builder_cls but the dataclass is used in case we may need additional metadata""" + + scene_builder_cls: type[scene_builder.SceneBuilder] + + +REGISTERED_SCENE_BUILDERS: Dict[str, SceneBuilderSpec] = {} + + +def register_scene_builder(uid: str, override=False): + """A decorator to register scene builders into ManiSkill so they can be used easily by string uid. + + Args: + uid (str): unique id of the scene builder class. + override (bool): whether to override the scene builder if it is already registered. + """ + + def _register_scene_builder(scene_builder_cls: type[scene_builder.SceneBuilder]): + if uid in REGISTERED_SCENE_BUILDERS: + if override: + logger.warn(f"Overriding registered scene builder {uid}") + REGISTERED_SCENE_BUILDERS.pop(uid) + else: + logger.warn( + f"Scene Builder {uid} is already registered. Skip registration." + ) + return scene_builder_cls + + REGISTERED_SCENE_BUILDERS[uid] = SceneBuilderSpec( + scene_builder_cls=scene_builder_cls + ) + return scene_builder_cls + + return _register_scene_builder diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..61fcf83a0bd4b73a78ec235c83dbd5090fcdae70 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/__init__.py @@ -0,0 +1 @@ +from .scene_builder import ReplicaCADSceneBuilder diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a077c18ca436e60a0ba6776e4a69053c9830765d Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/__pycache__/scene_builder.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/__pycache__/scene_builder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..67d4c3be84d2699ae13adfa2e06364d0dabc3dda Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/__pycache__/scene_builder.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/metadata/scene_configs.json b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/metadata/scene_configs.json new file mode 100644 index 0000000000000000000000000000000000000000..0c2df87f7691c818e68b3fd56f24aa826f685bd5 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/metadata/scene_configs.json @@ -0,0 +1,96 @@ +{ + "scenes": [ + "apt_0.scene_instance.json", + "apt_1.scene_instance.json", + "apt_2.scene_instance.json", + "apt_3.scene_instance.json", + "apt_4.scene_instance.json", + "apt_5.scene_instance.json" + ], + "staging_scenes": [ + "v3_sc0_staging_00.scene_instance.json", + "v3_sc0_staging_01.scene_instance.json", + "v3_sc0_staging_02.scene_instance.json", + "v3_sc0_staging_03.scene_instance.json", + "v3_sc0_staging_04.scene_instance.json", + "v3_sc0_staging_05.scene_instance.json", + "v3_sc0_staging_06.scene_instance.json", + "v3_sc0_staging_07.scene_instance.json", + "v3_sc0_staging_08.scene_instance.json", + "v3_sc0_staging_09.scene_instance.json", + "v3_sc0_staging_10.scene_instance.json", + "v3_sc0_staging_11.scene_instance.json", + "v3_sc0_staging_12.scene_instance.json", + "v3_sc0_staging_13.scene_instance.json", + "v3_sc0_staging_14.scene_instance.json", + "v3_sc0_staging_15.scene_instance.json", + "v3_sc0_staging_16.scene_instance.json", + "v3_sc0_staging_17.scene_instance.json", + "v3_sc0_staging_18.scene_instance.json", + "v3_sc0_staging_19.scene_instance.json", + "v3_sc0_staging_20.scene_instance.json", + "v3_sc1_staging_00.scene_instance.json", + "v3_sc1_staging_01.scene_instance.json", + "v3_sc1_staging_02.scene_instance.json", + "v3_sc1_staging_03.scene_instance.json", + "v3_sc1_staging_04.scene_instance.json", + "v3_sc1_staging_05.scene_instance.json", + "v3_sc1_staging_06.scene_instance.json", + "v3_sc1_staging_07.scene_instance.json", + "v3_sc1_staging_08.scene_instance.json", + "v3_sc1_staging_09.scene_instance.json", + "v3_sc1_staging_10.scene_instance.json", + "v3_sc1_staging_11.scene_instance.json", + "v3_sc1_staging_12.scene_instance.json", + "v3_sc1_staging_13.scene_instance.json", + "v3_sc1_staging_14.scene_instance.json", + "v3_sc1_staging_15.scene_instance.json", + "v3_sc1_staging_16.scene_instance.json", + "v3_sc1_staging_17.scene_instance.json", + "v3_sc1_staging_18.scene_instance.json", + "v3_sc1_staging_19.scene_instance.json", + "v3_sc1_staging_20.scene_instance.json", + "v3_sc2_staging_00.scene_instance.json", + "v3_sc2_staging_01.scene_instance.json", + "v3_sc2_staging_02.scene_instance.json", + "v3_sc2_staging_03.scene_instance.json", + "v3_sc2_staging_04.scene_instance.json", + "v3_sc2_staging_05.scene_instance.json", + "v3_sc2_staging_06.scene_instance.json", + "v3_sc2_staging_07.scene_instance.json", + "v3_sc2_staging_08.scene_instance.json", + "v3_sc2_staging_09.scene_instance.json", + "v3_sc2_staging_10.scene_instance.json", + "v3_sc2_staging_11.scene_instance.json", + "v3_sc2_staging_12.scene_instance.json", + "v3_sc2_staging_13.scene_instance.json", + "v3_sc2_staging_14.scene_instance.json", + "v3_sc2_staging_15.scene_instance.json", + "v3_sc2_staging_16.scene_instance.json", + "v3_sc2_staging_17.scene_instance.json", + "v3_sc2_staging_18.scene_instance.json", + "v3_sc2_staging_19.scene_instance.json", + "v3_sc2_staging_20.scene_instance.json", + "v3_sc3_staging_00.scene_instance.json", + "v3_sc3_staging_01.scene_instance.json", + "v3_sc3_staging_02.scene_instance.json", + "v3_sc3_staging_03.scene_instance.json", + "v3_sc3_staging_04.scene_instance.json", + "v3_sc3_staging_05.scene_instance.json", + "v3_sc3_staging_06.scene_instance.json", + "v3_sc3_staging_07.scene_instance.json", + "v3_sc3_staging_08.scene_instance.json", + "v3_sc3_staging_09.scene_instance.json", + "v3_sc3_staging_10.scene_instance.json", + "v3_sc3_staging_11.scene_instance.json", + "v3_sc3_staging_12.scene_instance.json", + "v3_sc3_staging_13.scene_instance.json", + "v3_sc3_staging_14.scene_instance.json", + "v3_sc3_staging_15.scene_instance.json", + "v3_sc3_staging_16.scene_instance.json", + "v3_sc3_staging_17.scene_instance.json", + "v3_sc3_staging_18.scene_instance.json", + "v3_sc3_staging_19.scene_instance.json", + "v3_sc3_staging_20.scene_instance.json" + ] +} diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..46c88efd97459fa95f8a71c52e24fd4904a69ae8 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__init__.py @@ -0,0 +1,8 @@ +from .variants import ( + ReplicaCADPrepareGroceriesTrainSceneBuilder, + ReplicaCADPrepareGroceriesValSceneBuilder, + ReplicaCADSetTableTrainSceneBuilder, + ReplicaCADSetTableValSceneBuilder, + ReplicaCADTidyHouseTrainSceneBuilder, + ReplicaCADTidyHouseValSceneBuilder, +) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c0fcdb7e8c004facc4982eaae9999b0c9c50a45 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__pycache__/scene_builder.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__pycache__/scene_builder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e4af576b335165241d9474d19cb9096f1d199b2a Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__pycache__/scene_builder.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__pycache__/variants.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__pycache__/variants.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae566e3552d17b269f472ead0fa44b2493a91a23 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/__pycache__/variants.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/scene_builder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/scene_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..494eec92dea9438cd46f91c5099c98f14b71206a --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/scene_builder.py @@ -0,0 +1,382 @@ +import copy +import itertools +import json +import os +import os.path as osp +from collections import defaultdict +from functools import cached_property +from pathlib import Path +from typing import Dict, List, Optional, Tuple + +import numpy as np +import sapien +import sapien.physx as physx +import torch +import transforms3d + +from mani_skill import ASSET_DIR +from mani_skill.utils import common +from mani_skill.utils.building import actors +from mani_skill.utils.scene_builder.replicacad import ReplicaCADSceneBuilder +from mani_skill.utils.structs import Actor, Articulation + +DEFAULT_HIDDEN_POS = [-10_000] * 3 + + +class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder): + + task_names: List[str] = ["set_table:train"] + + # init configs for Rearrange stasks are default_object_poses for each object type + init_configs: List[List[Dict[str, List[sapien.Pose]]]] = None + + def __init__(self, env): + # the Habitat Rearrange tasks build on the base ReplicaCAD scenes by creating episode configs + # each of which designate YCB object locations, articulation states, goal locations, etc + # so, this scenebuilder will inherit from the ReplicaCADSceneBuilder + # 1. the build_configs will be the base ReplicaCAD build configs + # 2. we will load RCAD scenes into their own parallel env as directed by build(). we will furthermore + # split the Rearrange episode configs by which RCAD scene they use. each RCAD scene + # must have its own parallel env as they have some statically-built actors + # 3. we then make as multiple copies of each YCB object in each parallel env. we also save + # we also save the pose data for each episode config + # 4. finally, when initializing the scene, we use init_config_idxs to index the poses for that + # episode config, allowing us to initialize the scene + # alternatively, we could rebuild each time we want to use a different episode config. this would be + # easier and allow for more "i.i.d." sampling of episode configs. however, using the above described + # method is much faster, as setting poses, qpos, etc is much faster than rebuilding/destroying actors + + # init base replicacad scene builder first + super().__init__(env, include_staging_scenes=True) + + # load rearrange episode configs. we will not directly use these to build/init scenes, + # but we will save certain data from these configs + self._rearrange_configs = [] + for task_name in self.task_names: + task, split = task_name.split(":") + self._rearrange_configs += [ + osp.join(split, task, f) + for f in sorted( + os.listdir( + osp.join( + ASSET_DIR, + "scene_datasets/replica_cad_dataset/rearrange", + split, + task, + ), + ) + ) + if f.endswith(".json") + ] + + # keep track of which build config idxs are used for sampling + self.used_build_config_idxs = set() + bc_to_idx = dict((v, i) for i, v in enumerate(self.build_configs)) + for rc in self._rearrange_configs: + with open( + osp.join( + ASSET_DIR, + "scene_datasets/replica_cad_dataset/rearrange", + rc, + ), + "rb", + ) as f: + episode_json = json.load(f) + self.used_build_config_idxs.add( + bc_to_idx[Path(episode_json["scene_id"]).name] + ) + + def build( + self, build_config_idxs: List[int], init_config_names: Optional[list] = None + ): + if isinstance(build_config_idxs, int): + build_config_idxs = [build_config_idxs] * self.env.num_envs + assert all( + [bci in self.used_build_config_idxs for bci in build_config_idxs] + ), f"got one or more unused build_config_idxs in {build_config_idxs}; This RCAD Rearrange task only uses the following build_config_idxs: {self.used_build_config_idxs}" + assert ( + len(build_config_idxs) == self.env.num_envs + ), f"Got {len(build_config_idxs)} build_config_idxs but only have {self.env.num_envs} envs" + + # delete cached properties which are dependent on values recomputed at build time + self.__dict__.pop("init_config_names_to_idxs", None) + + # the build_config_idxs are idxs for the RCAD build configs + # super().build builds the base RCAD scenes (including static objects) + super().build(build_config_idxs) + + # EXTRACTING AND ORGANIZING EPISODE CONFIG DATA + # here we extract the ycb object poses for each episode config and sort them by + # which base RCAD config they use + # final init config list will map ith build config (i.e. the ith RCAD scene) to a list + # of default object poses for each episode config using the ith RCAD scene + + # get transformations to convert RCAD poses to poses that work in our scenes + q = transforms3d.quaternions.axangle2quat( + np.array([1, 0, 0]), theta=np.deg2rad(90) + ) + world_transform = sapien.Pose(q=q).inv() + obj_transform = sapien.Pose(q=q, p=[0, 0, 0.01]) + + # self.rcad_to_rearrange_configs: which rearrange episode configs use each rcad config + # default_object_poses: default poses for ycb objects from each rearrange episode config + self.rcad_to_rearrange_configs: Dict[str, List[str]] = dict() + default_object_poses: Dict[str, Dict[str, List[sapien.Pose]]] = dict() + if init_config_names is None: + init_config_names = self._rearrange_configs + for rc in init_config_names: + objects: Dict[str, List[sapien.Pose]] = defaultdict(list) + + with open( + osp.join( + ASSET_DIR, + "scene_datasets/replica_cad_dataset/rearrange", + rc, + ), + "rb", + ) as f: + episode_json = json.load(f) + + for actor_id, transformation in episode_json["rigid_objs"]: + actor_id = actor_id.split(".")[0] + objects[actor_id].append( + obj_transform * sapien.Pose(transformation) * world_transform + ) + + rcad_config_name = Path(episode_json["scene_id"]).name + if rcad_config_name not in self.rcad_to_rearrange_configs: + self.rcad_to_rearrange_configs[rcad_config_name] = [] + self.rcad_to_rearrange_configs[rcad_config_name].append(rc) + default_object_poses[rc] = objects + + # create init config + self.init_configs: List[List[Dict[str, List[sapien.Pose]]]] = [ + [ + default_object_poses[rc] + for rc in self.rcad_to_rearrange_configs[self.build_configs[bci]] + ] + for bci in build_config_idxs + ] + + # YCB OBJ BUILDING + # instead of making new YCB objs for each episode config, we will + # build multiple instances of each YCB object for each RCAD scene + # when initializing, we set poses according to the sampled init configs, + # and we hide any unused instances of YCB objects + rcad_config_to_num_ycb_objs_to_build: Dict[str, Dict[str, int]] = dict() + for rcad_config in self.rcad_to_rearrange_configs.keys(): + obj_ids = set() + for rearrange_config in self.rcad_to_rearrange_configs[rcad_config]: + for obj_id in default_object_poses[rearrange_config].keys(): + obj_ids.add(obj_id) + + num_ycb_objs_to_build = dict() + for obj_id in obj_ids: + num_ycb_objs_to_build[obj_id] = max( + [ + len(default_object_poses[rearrange_config][obj_id]) + for rearrange_config in self.rcad_to_rearrange_configs[ + rcad_config + ] + ] + ) + + rcad_config_to_num_ycb_objs_to_build[rcad_config] = num_ycb_objs_to_build + + # save num init configs per build config for init config sampling + self.num_init_configs_per_build_config = [ + len(self.rcad_to_rearrange_configs[self.build_configs[bci]]) + for bci in build_config_idxs + ] + + # find max number of each ycb obj needed to support all init configs in each parallel env + self.ycb_objs_per_env = [] + _running_default_hidden_pos_by_env = dict( + (env_num, copy.deepcopy(DEFAULT_HIDDEN_POS)) + for env_num in range(len(build_config_idxs)) + ) + self._default_hidden_poses: Dict[Actor, sapien.Pose] = dict() + for env_num, bci in enumerate(build_config_idxs): + rcad_config = self.build_configs[bci] + num_ycb_objs_to_build = rcad_config_to_num_ycb_objs_to_build[rcad_config] + + ycb_objs = defaultdict(list) + for actor_id, num_objs in num_ycb_objs_to_build.items(): + for no in range(num_objs): + obj_instance_name = f"env-{env_num}_{actor_id}-{no}" + builder = actors.get_actor_builder(self.scene, id=f"ycb:{actor_id}") + builder.set_scene_idxs([env_num]) + builder.initial_pose = sapien.Pose( + p=_running_default_hidden_pos_by_env[env_num] + ) + actor = builder.build(name=obj_instance_name) + + ycb_objs[actor_id].append(actor) + self._default_hidden_poses[actor] = sapien.Pose( + p=_running_default_hidden_pos_by_env[env_num] + ) + _running_default_hidden_pos_by_env[env_num][2] -= 10 + self.scene_objects[obj_instance_name] = actor + self.movable_objects[obj_instance_name] = actor + self.ycb_objs_per_env.append(ycb_objs) + + self.rcad_config_to_rearrange_ao_states: Dict[ + str, List[List[Tuple[Articulation, torch.Tensor]]] + ] = defaultdict(list) + for env_num, bci in enumerate(build_config_idxs): + rcad_config = self.build_configs[bci] + rearrange_ao_states: List[List[Tuple[Articulation, torch.Tensor]]] = [] + for rearrange_config in self.rcad_to_rearrange_configs[rcad_config]: + with open( + osp.join( + ASSET_DIR, + "scene_datasets/replica_cad_dataset/rearrange", + rearrange_config, + ), + "rb", + ) as f: + episode_json = json.load(f) + episode_ao_states: Dict[str, Dict[str, int]] = episode_json["ao_states"] + articulation_qpos_pairs: List[Tuple[Articulation, torch.Tensor]] = [] + for base_articulation_id, qpos_dict in episode_ao_states.items(): + aid, anum = base_articulation_id.split(":") + articulation = self.articulations[ + f"env-{env_num}_{aid[:-1]}-{int(anum)}" + ] + base_qpos = torch.zeros( + articulation.max_dof, device=self.env.device + ) + for link_num, qpos_val in qpos_dict.items(): + qpos_idx = articulation.active_joints.index( + articulation.joints[int(link_num)] + ) + base_qpos[qpos_idx] = qpos_val + articulation_qpos_pairs.append((articulation, base_qpos)) + rearrange_ao_states.append(articulation_qpos_pairs) + self.rcad_config_to_rearrange_ao_states[rcad_config] = rearrange_ao_states + + # TODO (arth): fix this to work with partial resets + def initialize(self, env_idx: torch.Tensor, init_config_idxs: List[int]): + assert all( + [isinstance(ici, int) for ici in init_config_idxs] + ), f"init_config_idxs should be list of ints, instead got {init_config_idxs}" + + init_config_idxs: torch.Tensor = common.to_tensor( + init_config_idxs, device=self.env.device + ).to(torch.int) + if env_idx.numel() != init_config_idxs.numel(): + init_config_idxs = init_config_idxs[env_idx] + + # get sampled init configs + sampled_init_configs = [ + self.init_configs[env_num][idx] + for env_num, idx in zip(env_idx, init_config_idxs) + ] + + # sometimes, poses from end of prev episode can cause issues with articulations + # we can avoid this by setting poses, but shifting non-hidden objects away from the scene + for env_num, init_poses in zip(env_idx, sampled_init_configs): + ycb_objs = self.ycb_objs_per_env[env_num] + for obj_name in ycb_objs: + for obj, pose in itertools.zip_longest( + ycb_objs[obj_name], init_poses[obj_name], fillvalue=None + ): + if pose is None: + self.hide_actor(obj) + else: + temp_p = pose.p + temp_p[..., 2] += 1000 + self.show_actor(obj, sapien.Pose(q=pose.q, p=temp_p)) + + if self.scene.gpu_sim_enabled: + self.scene._gpu_apply_all() + self.scene._gpu_fetch_all() + + # initialize base scenes + super().initialize(env_idx) + + # teleport robot away for init + self.env.agent.robot.set_pose(sapien.Pose([-10, 0, -100])) + + # if pose given by init config, set pose + # if pose not given, hide extra ycb obj by teleporting away and + # turning off collisions with other hidden objs + for env_num, init_poses in zip(env_idx, sampled_init_configs): + ycb_objs = self.ycb_objs_per_env[env_num] + for obj_name in ycb_objs: + for obj, pose in itertools.zip_longest( + ycb_objs[obj_name], init_poses[obj_name], fillvalue=None + ): + if pose is None: + self.hide_actor(obj) + else: + self.show_actor(obj, pose) + + # set articulation qpos as needed + # TODO (arth): also shift objs inside the articulation as needed + # NOTE (arth): for now the rearrange configs only have the fridge move, + # so above only an issue when one can generate their own + # set the kitchen counter in the ao_configs + for env_num, ici in zip(env_idx, init_config_idxs): + rcad_config = self.build_configs[self.build_config_idxs[env_num]] + ao_states = self.rcad_config_to_rearrange_ao_states[rcad_config][ici] + for articulation, qpos in ao_states: + articulation_scene_idxs = articulation._scene_idxs.tolist() + base_qpos = articulation.qpos + base_qpos[articulation_scene_idxs.index(env_num)] *= 0 + base_qpos[articulation_scene_idxs.index(env_num)] = qpos + reset_idxs = [ + bn + for bn, en in enumerate(articulation._scene_idxs) + if en in env_idx + ] + articulation.set_qpos(base_qpos[reset_idxs]) + articulation.set_qvel(articulation.qvel[reset_idxs] * 0) + + if self.scene.gpu_sim_enabled and len(env_idx) == self.env.num_envs: + self.scene._gpu_apply_all() + self.scene.px.gpu_update_articulation_kinematics() + self.scene.px.step() + self.scene._gpu_fetch_all() + + # teleport robot back to correct location + if self.env.robot_uids == "fetch": + self.env.agent.reset(self.env.agent.keyframes["rest"].qpos) + self.env.agent.robot.set_pose(sapien.Pose([-1, 0, 0.02])) + else: + raise NotImplementedError(self.env.robot_uids) + + def sample_build_config_idxs(self): + used_build_config_idxs = list(self.used_build_config_idxs) + return [ + used_build_config_idxs[i] + for i in torch.randint( + low=0, high=len(used_build_config_idxs), size=(self.env.num_envs,) + ).tolist() + ] + + def sample_init_config_idxs(self): + low = torch.zeros(self.env.num_envs, dtype=torch.int) + high = torch.tensor(self.num_init_configs_per_build_config).int() + size = (self.env.num_envs,) + return ( + (torch.randint(2**63 - 1, size=size) % (high - low).int() + low) + .int() + .tolist() + ) + + def hide_actor(self, actor: Actor): + actor.set_pose(self._default_hidden_poses[actor]) + + def show_actor(self, actor: Actor, pose: sapien.Pose): + actor.set_pose(pose) + + @cached_property + def init_config_names_to_idxs(self) -> int: + + _init_config_names_to_idx = dict() + for rearrange_configs in self.rcad_to_rearrange_configs.values(): + for i, rc in enumerate(rearrange_configs): + _init_config_names_to_idx[rc] = i + + return _init_config_names_to_idx diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/variants.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/variants.py new file mode 100644 index 0000000000000000000000000000000000000000..34b06b71838a0355a7f6db1bbb74b3ca0492e802 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/rearrange/variants.py @@ -0,0 +1,32 @@ +from .scene_builder import ReplicaCADRearrangeSceneBuilder +from mani_skill.utils.scene_builder.registration import register_scene_builder + + +@register_scene_builder("ReplicaCADTidyHouseTrain") +class ReplicaCADTidyHouseTrainSceneBuilder(ReplicaCADRearrangeSceneBuilder): + task_names = ["tidy_house:train"] + + +@register_scene_builder("ReplicaCADTidyHouseVal") +class ReplicaCADTidyHouseValSceneBuilder(ReplicaCADRearrangeSceneBuilder): + task_names = ["tidy_house:val"] + + +@register_scene_builder("ReplicaCADPrepareGroceriesTrain") +class ReplicaCADPrepareGroceriesTrainSceneBuilder(ReplicaCADRearrangeSceneBuilder): + task_names = ["prepare_groceries:train"] + + +@register_scene_builder("ReplicaCADPrepareGroceriesVal") +class ReplicaCADPrepareGroceriesValSceneBuilder(ReplicaCADRearrangeSceneBuilder): + task_names = ["prepare_groceries:val"] + + +@register_scene_builder("ReplicaCADSetTableTrain") +class ReplicaCADSetTableTrainSceneBuilder(ReplicaCADRearrangeSceneBuilder): + task_names = ["set_table:train"] + + +@register_scene_builder("ReplicaCADSetTableVal") +class ReplicaCADSetTableValSceneBuilder(ReplicaCADRearrangeSceneBuilder): + task_names = ["set_table:val"] diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/scene_builder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/scene_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..15403014dd3f9c6ca0148994bc8b07b95d4a53a8 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/replicacad/scene_builder.py @@ -0,0 +1,348 @@ +""" +Code for building scenes from the ReplicaCAD dataset https://aihabitat.org/datasets/replica_cad/ + +This code is also heavily commented to serve as a tutorial for how to build custom scenes from scratch and/or port scenes over from other datasets/simulators +""" + +import json +import os.path as osp +from collections import defaultdict +from functools import cached_property +from pathlib import Path +from typing import Dict, List, Tuple, Union + +import numpy as np +import sapien +import sapien.physx as physx +import torch +import transforms3d +import trimesh + +from mani_skill import ASSET_DIR +from mani_skill.agents.robots.fetch import ( + FETCH_BASE_COLLISION_BIT, + FETCH_WHEELS_COLLISION_BIT, +) +from mani_skill.utils.scene_builder import SceneBuilder +from mani_skill.utils.scene_builder.registration import register_scene_builder +from mani_skill.utils.structs import Actor, Articulation + +DATASET_CONFIG_DIR = osp.join(osp.dirname(__file__), "metadata") + +IGNORE_FETCH_COLLISION_STRS = ["mat", "rug", "carpet"] + + +@register_scene_builder("ReplicaCAD") +class ReplicaCADSceneBuilder(SceneBuilder): + + robot_initial_pose = sapien.Pose( + p=[-1, 0, 0.02] + ) # generally a safe initial spawn pose for the Fetch robot + + builds_lighting = True # we set this true because the ReplicaCAD dataset defines some lighting for us so we don't need the default option from ManiSkill + + # build configs for RCAD are string file names + build_configs: List[str] = None + + def __init__(self, env, robot_init_qpos_noise=0.02, include_staging_scenes=False): + super().__init__(env, robot_init_qpos_noise=robot_init_qpos_noise) + # Scene datasets from any source generally have several configurations, each of which may involve changing object geometries, poses etc. + # You should store this configuration information in the self.build_configs list, which permits the code to sample from when + # simulating more than one scene or performing reconfiguration + + # for ReplicaCAD we have saved the list of all scene configuration files from the dataset to a local json file + with open(osp.join(DATASET_CONFIG_DIR, "scene_configs.json")) as f: + build_config_json = json.load(f) + self.build_configs = build_config_json["scenes"] + if include_staging_scenes: + self.build_configs += build_config_json["staging_scenes"] + + # cache navigable positions from files + # assumes navigable position files saved + self._navigable_positions = [None] * len(self.build_configs) + self.build_config_idxs: List[int] = None + + def build(self, build_config_idxs: Union[int, List[int]]): + # build_config_idxs is a list of integers, where the ith value is the scene idx for the ith parallel env + if isinstance(build_config_idxs, int): + build_config_idxs = [build_config_idxs] * self.env.num_envs + assert all([isinstance(bci, int) for bci in build_config_idxs]) + assert len(build_config_idxs) == self.env.num_envs + + # delete cached properties which are dependent on values recomputed at build time + self.__dict__.pop("ray_traced_lighting", None) + + # Keep track of movable and static objects, build_config_idxs for envs, and poses + self.build_config_idxs = build_config_idxs + self.scene_objects: Dict[str, Actor] = dict() + self.movable_objects: Dict[str, Actor] = dict() + self.articulations: Dict[str, Articulation] = dict() + self._default_object_poses: List[Tuple[Actor, sapien.Pose]] = [] + + # keep track of background objects separately as we need to disable mobile robot collisions + # note that we will create a merged actor using these objects to represent the bg + bgs = [None] * self.env.num_envs + for bci in np.unique(build_config_idxs): + """ + Given a list of sampled build_config_idxs, build/load the scene objects + + TODO (arth): return builder option to set static/dynamic in env + - for now leave as-is since has smaller change in performance + """ + + env_idx = [i for i, v in enumerate(build_config_idxs) if v == bci] + unique_id = "scs-" + str(env_idx).replace(" ", "") + build_config_path = self.build_configs[bci] + + # We read the json config file describing the scene setup for the selected ReplicaCAD scene + with open( + osp.join( + ASSET_DIR, + "scene_datasets/replica_cad_dataset/configs/scenes", + build_config_path, + ), + "rb", + ) as f: + build_config_json = json.load(f) + + # The complex part of porting over scene datasets is that each scene dataset often has it's own format and there is no + # one size fits all solution to read that format and use it. The best way to port a scene dataset over is to look + # at the configuration files, get a sense of the pattern and find how they reference .glb model files and potentially + # decomposed convex meshes for physical simulation + + # ReplicaCAD stores the background model here + background_template_name = osp.basename( + build_config_json["stage_instance"]["template_name"] + ) + bg_path = str( + ASSET_DIR + / f"scene_datasets/replica_cad_dataset/stages/{background_template_name}.glb" + ) + builder = self.scene.create_actor_builder() + # Note all ReplicaCAD assets are rotated by 90 degrees as they use a different xyz convention to SAPIEN/ManiSkill. + q = transforms3d.quaternions.axangle2quat( + np.array([1, 0, 0]), theta=np.deg2rad(90) + ) + bg_pose = sapien.Pose(q=q) + + # When creating objects that do not need to be moved ever, you must provide the pose of the object ahead of time + # and use builder.build_static. Objects such as the scene background (also called a stage) fits in this category + builder.add_visual_from_file(bg_path) + builder.add_nonconvex_collision_from_file(bg_path) + builder.initial_pose = bg_pose + builder.set_scene_idxs(env_idx) + bg = builder.build_static(name=f"{unique_id}_scene_background") + for i, env_num in enumerate(env_idx): + bgs[env_num] = bg._objs[i] + + # In scenes, there will always be dynamic objects, kinematic objects, and static objects. + # In the case of ReplicaCAD there are only dynamic and static objects. Since dynamic objects can be moved during simulation + # we need to keep track of the initial poses of each dynamic actor we create. + for obj_num, obj_meta in enumerate(build_config_json["object_instances"]): + + # Again, for any dataset you will have to figure out how they reference object files + # Note that ASSET_DIR will always refer to the ~/.maniskill/data folder or whatever MS_ASSET_DIR is set to + obj_config_path = osp.join( + ASSET_DIR, + "scene_datasets/replica_cad_dataset/configs/objects", + f"{osp.basename(obj_meta['template_name'])}.object_config.json", + ) + with open(obj_config_path) as f: + obj_config = json.load(f) + visual_file = osp.join( + osp.dirname(obj_config_path), obj_config["render_asset"] + ) + if "collision_asset" in obj_config: + collision_file = osp.join( + osp.dirname(obj_config_path), obj_config["collision_asset"] + ) + builder = self.scene.create_actor_builder() + pos = obj_meta["translation"] + rot = obj_meta["rotation"] + # left multiplying by the offset quaternion we used for the stage/scene background as all assets in ReplicaCAD are rotated by 90 degrees + pose = sapien.Pose(q=q) * sapien.Pose(pos, rot) + + actor_name = f'{obj_meta["template_name"]}-{obj_num}' + # Neatly for simulation, ReplicaCAD specifies if an object is meant to be simulated as dynamic (can be moved like pots) or static (must stay still, like kitchen counters) + if obj_meta["motion_type"] == "DYNAMIC": + builder.add_visual_from_file(visual_file) + if ( + "use_bounding_box_for_collision" in obj_config + and obj_config["use_bounding_box_for_collision"] + ): + # some dynamic objects do not have decomposed convex meshes and instead should use a simple bounding box for collision detection + # in this case we use the add_convex_collision_from_file function of SAPIEN which just creates a convex collision based on the visual mesh + builder.add_convex_collision_from_file(visual_file) + else: + builder.add_multiple_convex_collisions_from_file(collision_file) + builder.initial_pose = pose + builder.set_scene_idxs(env_idx) + actor = builder.build(name=f"{unique_id}_{actor_name}") + self._default_object_poses.append((actor, pose)) + + # Add dynamic objects to movable_objects + for env_num in env_idx: + self.movable_objects[f"env-{env_num}_{actor_name}"] = actor + elif obj_meta["motion_type"] == "STATIC": + builder.add_visual_from_file(visual_file) + # for static (and dynamic) objects you don't need to use pre convex decomposed meshes and instead can directly + # add the non convex collision mesh based on the visual mesh + builder.add_nonconvex_collision_from_file(visual_file) + builder.initial_pose = pose + builder.set_scene_idxs(env_idx) + actor = builder.build_static(name=f"{unique_id}_{actor_name}") + + # Add all objects to scene_objects + for env_num in env_idx: + self.scene_objects[f"env-{env_num}_{actor_name}"] = actor + + # Certain objects, such as mats, rugs, and carpets, are on the ground and should not collide with the Fetch base + if any([x in actor_name for x in IGNORE_FETCH_COLLISION_STRS]): + self.disable_fetch_move_collisions( + actor, disable_base_collisions=True + ) + + # ReplicaCAD also provides articulated objects + articulation_to_num = defaultdict(int) + for i, articulated_meta in enumerate( + build_config_json["articulated_object_instances"] + ): + + template_name = articulated_meta["template_name"] + if "door" in template_name: + continue + pos = articulated_meta["translation"] + rot = articulated_meta["rotation"] + urdf_path = osp.join( + ASSET_DIR, + f"scene_datasets/replica_cad_dataset/urdf/{template_name}/{template_name}.urdf", + ) + urdf_loader = self.scene.create_urdf_loader() + articulation_name = ( + f"{template_name}-{articulation_to_num[template_name]}" + ) + urdf_loader.name = f"{unique_id}_{articulation_name}" + urdf_loader.fix_root_link = articulated_meta["fixed_base"] + urdf_loader.disable_self_collisions = True + if "uniform_scale" in articulated_meta: + urdf_loader.scale = articulated_meta["uniform_scale"] + builder = urdf_loader.parse(urdf_path)["articulation_builders"][0] + pose = sapien.Pose(q=q) * sapien.Pose(pos, rot) + builder.initial_pose = pose + builder.set_scene_idxs(env_idx) + articulation = builder.build() + self._default_object_poses.append((articulation, pose)) + + # for now classify articulated objects as "movable" object + for env_num in env_idx: + self.articulations[f"env-{env_num}_{articulation_name}"] = ( + articulation + ) + self.scene_objects[f"env-{env_num}_{articulation_name}"] = ( + articulation + ) + + for link in articulation.links: + link.set_collision_group_bit( + group=2, bit_idx=FETCH_WHEELS_COLLISION_BIT, bit=1 + ) + + articulation_to_num[template_name] += 1 + + if self._navigable_positions[bci] is None: + mesh_fp = ( + Path(ASSET_DIR) + / "scene_datasets/replica_cad_dataset/configs/scenes" + / ( + Path(self.build_configs[bci]).stem + + f".{str(self.env.robot_uids)}.navigable_positions.obj" + ) + ) + if mesh_fp.exists(): + self._navigable_positions[bci] = trimesh.load(mesh_fp) + + # # ReplicaCAD's lighting isn't great for raytracing, so we define our own + if self.ray_traced_lighting: + for sub_scene in self.scene.sub_scenes: + sub_scene.set_environment_map( + str( + ( + Path(__file__).parent / "autumn_field_puresky_4k.hdr" + ).absolute() + ) + ) + else: + self.scene.set_ambient_light([0.3] * 3) + color = np.array([1.0, 0.8, 0.5]) * 2 + # entrance + self.scene.add_point_light([-1.1, 2.775, 2.3], color=color) + # dining area + self.scene.add_point_light([-0.5, -1.44, 2.3], color=color) + # dining back + self.scene.add_point_light([2.4, -1.6, 2.3], color=color) + # living room + self.scene.add_point_light([2.5, -6.1, 2.3], color=color) + # stair + self.scene.add_point_light([3.14, 3.24, 3], color=color) + + # merge actors into one + self.bg = Actor.create_from_entities( + bgs, + scene=self.scene, + scene_idxs=torch.arange(self.env.num_envs, dtype=int), + shared_name="scene_background", + ) + + # For the purposes of physical simulation, we disable collisions between the Fetch robot and the scene background + self.disable_fetch_move_collisions(self.bg) + + def initialize(self, env_idx: torch.Tensor): + + # teleport robot away for init + self.env.agent.robot.set_pose(sapien.Pose([-10, 0, -100])) + + for obj, pose in self._default_object_poses: + obj.set_pose(pose) + if isinstance(obj, Articulation): + # note that during initialization you may only ever change poses/qpos of objects in scenes being reset + obj.set_qpos(obj.qpos[0] * 0) + obj.set_qvel(obj.qvel[0] * 0) + + if self.scene.gpu_sim_enabled and len(env_idx) == self.env.num_envs: + self.scene._gpu_apply_all() + self.scene.px.gpu_update_articulation_kinematics() + self.scene.px.step() + self.scene._gpu_fetch_all() + + # teleport robot back to correct location + if self.env.robot_uids == "fetch": + self.env.agent.reset(self.env.agent.keyframes["rest"].qpos) + self.env.agent.robot.set_pose(sapien.Pose([-1, 0, 0.02])) + else: + raise NotImplementedError(self.env.robot_uids) + + def disable_fetch_move_collisions( + self, + actor: Actor, + disable_base_collisions=False, + ): + actor.set_collision_group_bit( + group=2, bit_idx=FETCH_WHEELS_COLLISION_BIT, bit=1 + ) + if disable_base_collisions: + actor.set_collision_group_bit( + group=2, bit_idx=FETCH_BASE_COLLISION_BIT, bit=1 + ) + + @property + def navigable_positions(self) -> List[trimesh.Trimesh]: + return [self._navigable_positions[bci] for bci in self.build_config_idxs] + + @cached_property + def ray_traced_lighting(self) -> bool: + return self.env._custom_human_render_camera_configs.get( + "shader_pack", None + ) in [ + "rt", + "rt-fast", + ] diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/__pycache__/scene_builder.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/__pycache__/scene_builder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2c9f828a72e2c12056e75781f76719330fce3bb Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/__pycache__/scene_builder.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/fixtures/__pycache__/counter.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/fixtures/__pycache__/counter.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41c7297ba18b034fcb0b560dcd353faed342d986 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/fixtures/__pycache__/counter.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5718601a5783404e41ced7538b5db59a73e805a4 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/kitchen_object_utils.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/kitchen_object_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f597fba65053c23a58a8e41d886d7722daad1878 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/kitchen_object_utils.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/kitchen_objects.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/kitchen_objects.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b913c6fddcc94841882f6f6e6ec53073f43e450 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/kitchen_objects.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/objects.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/objects.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7b731d259a001ca9863b08413f7f69a78a5d4c1 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/__pycache__/objects.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/kitchen_object_utils.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/kitchen_object_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..8331c7ed3e192de6753c51b6eba6e155007fb877 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/kitchen_object_utils.py @@ -0,0 +1,434 @@ +import math +import os +import xml.etree.ElementTree as ET +from copy import deepcopy + +import numpy as np + +from mani_skill.utils.scene_builder.robocasa.objects.kitchen_objects import ( + OBJ_CATEGORIES, + OBJ_GROUPS, +) +from mani_skill.utils.scene_builder.robocasa.utils.mjcf_utils import ( + find_elements, + string_to_array, +) +from mani_skill.utils.scene_builder.robocasa.utils.scene_utils import ROBOCASA_ASSET_DIR + +BASE_ASSET_ZOO_PATH = str(ROBOCASA_ASSET_DIR / "objects") + + +class ObjCat: + """ + Class that encapsulates data for an object category. + + Args: + name (str): name of the object category + + types (tuple) or (str): type(s)/categories the object belongs to. Examples include meat, sweets, fruit, etc. + + model_folders (list): list of folders containing the MJCF models for the object category + + exclude (list): list of model names to exclude + + graspable (bool): whether the object is graspable + + washable (bool): whether the object is washable + + microwavable (bool): whether the object is microwavable + + cookable (bool): whether the object is cookable + + freezable (bool): whether the object is freezable + + scale (float): scale of the object meshes/geoms + + solimp (tuple): solimp values for the object meshes/geoms + + solref (tuple): solref values for the object meshes/geoms + + density (float): density of the object meshes/geoms + + friction (tuple): friction values for the object meshes/geoms + + priority: priority of the object + + aigen_cat (bool): True if the object is an AI-generated object otherwise its an objaverse object + """ + + def __init__( + self, + name, + types, + model_folders=None, + exclude=None, + graspable=False, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + scale=1.0, + solimp=(0.998, 0.998, 0.001), + solref=(0.001, 2), + density=100, + friction=(0.95, 0.3, 0.1), + priority=None, + aigen_cat=False, + ): + self.name = name + if not isinstance(types, tuple): + types = (types,) + self.types = types + + self.aigen_cat = aigen_cat + + self.graspable = graspable + self.washable = washable + self.microwavable = microwavable + self.cookable = cookable + self.freezable = freezable + + self.scale = scale + self.solimp = solimp + self.solref = solref + self.density = density + self.friction = friction + self.priority = priority + self.exclude = exclude or [] + + if model_folders is None: + subf = "aigen_objs" if self.aigen_cat else "objaverse" + model_folders = ["{}/{}".format(subf, name)] + cat_mjcf_paths = [] + for folder in model_folders: + cat_path = os.path.join(BASE_ASSET_ZOO_PATH, folder) + for root, _, files in os.walk(cat_path): + if "model.xml" in files: + model_name = os.path.basename(root) + if model_name in self.exclude: + continue + cat_mjcf_paths.append(os.path.join(root, "model.xml")) + self.mjcf_paths = sorted(cat_mjcf_paths) + + def get_mjcf_kwargs(self): + """ + returns relevant data to apply to the MJCF model for the object category + """ + return deepcopy( + dict( + scale=self.scale, + solimp=self.solimp, + solref=self.solref, + density=self.density, + friction=self.friction, + priority=self.priority, + ) + ) + + +# update OBJ_CATEGORIES with ObjCat instances. Maps name to the different registries it can belong to +# and then maps the registry to the ObjCat instance +for (name, kwargs) in OBJ_CATEGORIES.items(): + + # get the properties that are common to both registries + common_properties = deepcopy(kwargs) + for k in common_properties.keys(): + assert k in [ + "graspable", + "washable", + "microwavable", + "cookable", + "freezable", + "types", + "aigen", + "objaverse", + ] + objaverse_kwargs = common_properties.pop("objaverse", None) + aigen_kwargs = common_properties.pop("aigen", None) + assert "scale" not in kwargs + OBJ_CATEGORIES[name] = {} + + # create instances + if objaverse_kwargs is not None: + objaverse_kwargs.update(common_properties) + OBJ_CATEGORIES[name]["objaverse"] = ObjCat(name=name, **objaverse_kwargs) + if aigen_kwargs is not None: + aigen_kwargs.update(common_properties) + OBJ_CATEGORIES[name]["aigen"] = ObjCat( + name=name, aigen_cat=True, **aigen_kwargs + ) + + +def sample_kitchen_object( + groups, + exclude_groups=None, + graspable=None, + washable=None, + microwavable=None, + cookable=None, + freezable=None, + rng=None, + obj_registries=("objaverse",), + split=None, + max_size=(None, None, None), + object_scale=None, +): + """ + Sample a kitchen object from the specified groups and within max_size bounds. + + Args: + groups (list or str): groups to sample from or the exact xml path of the object to spawn + + exclude_groups (str or list): groups to exclude + + graspable (bool): whether the sampled object must be graspable + + washable (bool): whether the sampled object must be washable + + microwavable (bool): whether the sampled object must be microwavable + + cookable (bool): whether whether the sampled object must be cookable + + freezable (bool): whether whether the sampled object must be freezable + + rng (np.random.Generator): random number object + + obj_registries (tuple): registries to sample from + + split (str): split to sample from. Split "A" specifies all but the last 3 object instances + (or the first half - whichever is larger), "B" specifies the rest, and None specifies all. + + max_size (tuple): max size of the object. If the sampled object is not within bounds of max size, function will resample + + object_scale (float): scale of the object. If set will multiply the scale of the sampled object by this value + + + Returns: + dict: kwargs to apply to the MJCF model for the sampled object + + dict: info about the sampled object - the path of the mjcf, groups which the object's category belongs to, the category of the object + the sampling split the object came from, and the groups the object was sampled from + """ + valid_object_sampled = False + while valid_object_sampled is False: + mjcf_kwargs, info = sample_kitchen_object_helper( + groups=groups, + exclude_groups=exclude_groups, + graspable=graspable, + washable=washable, + microwavable=microwavable, + cookable=cookable, + freezable=freezable, + rng=rng, + obj_registries=obj_registries, + split=split, + object_scale=object_scale, + ) + + # check if object size is within bounds + mjcf_path = info["mjcf_path"] + tree = ET.parse(mjcf_path) + root = tree.getroot() + bottom = string_to_array( + find_elements(root=root, tags="site", attribs={"name": "bottom_site"}).get( + "pos" + ) + ) + top = string_to_array( + find_elements(root=root, tags="site", attribs={"name": "top_site"}).get( + "pos" + ) + ) + horizontal_radius = string_to_array( + find_elements( + root=root, tags="site", attribs={"name": "horizontal_radius_site"} + ).get("pos") + ) + scale = mjcf_kwargs["scale"] + obj_size = ( + np.array( + [horizontal_radius[0] * 2, horizontal_radius[1] * 2, top[2] - bottom[2]] + ) + * scale + ) + valid_object_sampled = True + for i in range(3): + if max_size[i] is not None and obj_size[i] > max_size[i]: + valid_object_sampled = False + + return mjcf_kwargs, info + + +def sample_kitchen_object_helper( + groups, + exclude_groups=None, + graspable=None, + washable=None, + microwavable=None, + cookable=None, + freezable=None, + rng=None, + obj_registries=("objaverse",), + split=None, + object_scale=None, +): + """ + Helper function to sample a kitchen object. + + Args: + groups (list or str): groups to sample from or the exact xml path of the object to spawn + + exclude_groups (str or list): groups to exclude + + graspable (bool): whether the sampled object must be graspable + + washable (bool): whether the sampled object must be washable + + microwavable (bool): whether the sampled object must be microwavable + + cookable (bool): whether whether the sampled object must be cookable + + freezable (bool): whether whether the sampled object must be freezable + + rng (np.random.Generator): random number object + + obj_registries (tuple): registries to sample from + + split (str): split to sample from. Split "A" specifies all but the last 3 object instances + (or the first half - whichever is larger), "B" specifies the rest, and None specifies all. + + object_scale (float): scale of the object. If set will multiply the scale of the sampled object by this value + + + Returns: + dict: kwargs to apply to the MJCF model for the sampled object + + dict: info about the sampled object - the path of the mjcf, groups which the object's category belongs to, the category of the object + the sampling split the object came from, and the groups the object was sampled from + """ + if rng is None: + rng = np.random.default_rng() + + # option to spawn specific object instead of sampling from a group + if isinstance(groups, str) and groups.endswith(".xml"): + mjcf_path = groups + # reverse look up mjcf_path to category + mjcf_kwargs = dict() + cat = None + obj_found = False + for cand_cat in OBJ_CATEGORIES: + for reg in obj_registries: + if ( + reg in OBJ_CATEGORIES[cand_cat] + and mjcf_path in OBJ_CATEGORIES[cand_cat][reg].mjcf_paths + ): + mjcf_kwargs = OBJ_CATEGORIES[cand_cat][reg].get_mjcf_kwargs() + cat = cand_cat + obj_found = True + break + if obj_found: + break + if obj_found is False: + raise ValueError + mjcf_kwargs["mjcf_path"] = mjcf_path + else: + if not isinstance(groups, tuple) and not isinstance(groups, list): + groups = [groups] + + if exclude_groups is None: + exclude_groups = [] + if not isinstance(exclude_groups, tuple) and not isinstance( + exclude_groups, list + ): + exclude_groups = [exclude_groups] + + invalid_categories = [] + for g in exclude_groups: + for cat in OBJ_GROUPS[g]: + invalid_categories.append(cat) + + valid_categories = [] + for g in groups: + for cat in OBJ_GROUPS[g]: + # don't repeat if already added + if cat in valid_categories: + continue + if cat in invalid_categories: + continue + + # don't include if category not represented in any registry + cat_in_any_reg = np.any( + [reg in OBJ_CATEGORIES[cat] for reg in obj_registries] + ) + if not cat_in_any_reg: + continue + + invalid = False + for reg in obj_registries: + if reg not in OBJ_CATEGORIES[cat]: + continue + cat_meta = OBJ_CATEGORIES[cat][reg] + if graspable is True and cat_meta.graspable is not True: + invalid = True + if washable is True and cat_meta.washable is not True: + invalid = True + if microwavable is True and cat_meta.microwavable is not True: + invalid = True + if cookable is True and cat_meta.cookable is not True: + invalid = True + if freezable is True and cat_meta.freezable is not True: + invalid = True + + if invalid: + continue + + valid_categories.append(cat) + + cat = rng.choice(valid_categories) + + choices = {reg: [] for reg in obj_registries} + + for reg in obj_registries: + if reg not in OBJ_CATEGORIES[cat]: + choices[reg] = [] + continue + reg_choices = deepcopy(OBJ_CATEGORIES[cat][reg].mjcf_paths) + + # exclude out objects based on split + if split is not None: + split_th = max(len(choices) - 3, int(math.ceil(len(reg_choices) / 2))) + if split == "A": + reg_choices = reg_choices[:split_th] + elif split == "B": + reg_choices = reg_choices[split_th:] + else: + raise ValueError + choices[reg] = reg_choices + + chosen_reg = rng.choice( + obj_registries, + p=np.array([len(choices[reg]) for reg in obj_registries]) + / sum(len(choices[reg]) for reg in obj_registries), + ) + + mjcf_path = rng.choice(choices[chosen_reg]) + mjcf_kwargs = OBJ_CATEGORIES[cat][chosen_reg].get_mjcf_kwargs() + mjcf_kwargs["mjcf_path"] = mjcf_path + + if object_scale is not None: + mjcf_kwargs["scale"] *= object_scale + + groups_containing_sampled_obj = [] + for group, group_cats in OBJ_GROUPS.items(): + if cat in group_cats: + groups_containing_sampled_obj.append(group) + + info = { + "groups_containing_sampled_obj": groups_containing_sampled_obj, + "groups": groups, + "cat": cat, + "split": split, + "mjcf_path": mjcf_path, + } + + return mjcf_kwargs, info diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/kitchen_objects.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/kitchen_objects.py new file mode 100644 index 0000000000000000000000000000000000000000..18f9f4a3163cb0c247344305c1d5947cf2f5d0a3 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/kitchen_objects.py @@ -0,0 +1,2104 @@ +from mani_skill.utils.scene_builder.robocasa.utils.scene_utils import ROBOCASA_ASSET_DIR + +# import robocasa + +BASE_ASSET_ZOO_PATH = str(ROBOCASA_ASSET_DIR / "objects") + +# Constant that contains information about each object category. These will be used to generate the ObjCat classes for each category +OBJ_CATEGORIES = dict( + liquor=dict( + types=("drink", "alcohol"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + model_folders=["aigen_objs/alcohol"], + scale=1.50, + ), + objaverse=dict( + model_folders=["objaverse/alcohol"], + scale=1.35, + ), + ), + apple=dict( + types=("fruit"), + graspable=True, + washable=True, + microwavable=False, + cookable=True, + freezable=False, + aigen=dict( + scale=1.0, + ), + objaverse=dict( + scale=0.90, + ), + ), + avocado=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=0.90, + ), + objaverse=dict( + scale=0.90, + ), + ), + bagel=dict( + types=("bread_food"), + graspable=False, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.2, + ), + objaverse=dict( + exclude=[ + "bagel_8", + ], + ), + ), + bagged_food=dict( + types=("packaged_food"), + graspable=False, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.1, + ), + objaverse=dict( + exclude=[ + "bagged_food_12", + ], + ), + ), + baguette=dict( + types=("bread_food"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.35, + ), + objaverse=dict( + exclude=[ + "baguette_3", # small holes on ends + ], + ), + ), + banana=dict( + types=("fruit"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.10, + ), + objaverse=dict( + scale=0.95, + ), + ), + bar=dict( + types=("packaged_food"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=[1.25, 1.25, 1.75], + ), + objaverse=dict( + scale=[0.75, 0.75, 1.2], + exclude=[ + "bar_1", # small holes scattered + ], + ), + ), + bar_soap=dict( + types=("cleaner"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=[1.25, 1.25, 1.40], + ), + objaverse=dict( + scale=[0.95, 0.95, 1.05], + exclude=["bar_soap_2"], + ), + ), + beer=dict( + types=("drink", "alcohol"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.30, + ), + objaverse=dict(scale=1.15), + ), + bell_pepper=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.0, + ), + objaverse=dict( + scale=0.75, + ), + ), + bottled_drink=dict( + types=("drink"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.25, + ), + objaverse=dict(), + ), + bottled_water=dict( + types=("drink"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.30, + ), + objaverse=dict( + scale=1.10, + exclude=[ + "bottled_water_0", # minor hole at top + "bottled_water_5", # causing error. eigenvalues of mesh inertia violate A + B >= C + ], + ), + ), + bowl=dict( + types=("receptacle", "stackable"), + graspable=True, + washable=True, + microwavable=True, + cookable=False, + freezable=False, + aigen=dict( + scale=1.75, + ), + objaverse=dict( + scale=2.0, + exclude=[ + "bowl_21", # can see through from bottom of bowl + ], + ), + ), + boxed_drink=dict( + types=("drink"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.1, + ), + objaverse=dict( + scale=0.80, + exclude=[ + "boxed_drink_9", # hole on bottom + "boxed_drink_6", # hole on bottom + "boxed_drink_8", # hole on bottom + ], + ), + ), + boxed_food=dict( + types=("packaged_food"), + graspable=True, + washable=False, + microwavable=True, + cookable=False, + freezable=True, + aigen=dict( + scale=1.25, + ), + objaverse=dict( + scale=1.1, + exclude=[ + "boxed_food_5", # causing error. eigenvalues of mesh inertia violate A + B >= C + ], + # exclude=[ + # "boxed_food_5", + # "boxed_food_3", "boxed_food_1", "boxed_food_6", "boxed_food_11", "boxed_food_10", "boxed_food_8", "boxed_food_9", "boxed_food_7", "boxed_food_2", # self turning due to single collision geom + # ], + ), + ), + bread=dict( + types=("bread_food"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=[0.80, 0.80, 1.0], + ), + objaverse=dict(scale=[0.70, 0.70, 1.0], exclude=["bread_22"]), # hole on bottom + ), + broccoli=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.35, + ), + objaverse=dict( + scale=1.25, + exclude=[ + "broccoli_2", # holes on one part + ], + ), + ), + cake=dict( + types=("sweets"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=0.8, + ), + objaverse=dict( + scale=0.8, + ), + ), + can=dict( + types=("drink"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict(), + objaverse=dict( + exclude=[ + "can_10", # hole on bottom + "can_5", # causing error: faces of mesh have inconsistent orientation. + ], + ), + ), + candle=dict( + types=("decoration"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.5, + ), + objaverse=dict( + exclude=[ + "candle_11", # hole at bottom + # "candle_2", # can't see from bottom view angle + # "candle_15", # can't see from bottom view angle + ], + ), + ), + canned_food=dict( + types=("packaged_food"), + graspable=True, + washable=True, + microwavable=True, + cookable=False, + freezable=True, + aigen=dict( + scale=1.15, + ), + objaverse=dict( + scale=0.90, + exclude=[ + "canned_food_7", # holes at top and bottom + ], + ), + ), + carrot=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.25, + ), + objaverse=dict(), + ), + cereal=dict( + types=("packaged_food"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.15, + ), + objaverse=dict( + # exclude=[ + # "cereal_2", "cereal_5", "cereal_13", "cereal_3", "cereal_9", "cereal_0", "cereal_7", "cereal_4", "cereal_8", "cereal_12", "cereal_11", "cereal_1", "cereal_6", "cereal_10", # self turning due to single collision geom + # ] + ), + ), + cheese=dict( + types=("dairy"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.0, + ), + objaverse=dict( + scale=0.85, + ), + ), + chips=dict( + types=("packaged_food"), + graspable=False, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.5, + ), + objaverse=dict( + exclude=[ + "chips_12", # minor hole at bottom of bag + # "chips_2", # a weird texture at top/bottom but keeping this + ] + ), + ), + chocolate=dict( + types=("sweets"), + graspable=False, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=[1.0, 1.0, 1.35], + ), + objaverse=dict( + scale=[0.80, 0.80, 1.20], + exclude=[ + # "chocolate_2", # self turning due to single collision geom + ], + ), + ), + coffee_cup=dict( + types=("drink"), + graspable=True, + washable=False, + microwavable=True, + cookable=False, + freezable=False, + aigen=dict( + scale=1.35, + ), + objaverse=dict( + exclude=[ + "coffee_cup_18", # can see thru top + "coffee_cup_5", # can see thru from bottom side + "coffee_cup_19", # can see thru from bottom side + ], + ), + ), + condiment_bottle=dict( + types=("condiment"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.35, + model_folders=["aigen_objs/condiment"], + ), + objaverse=dict( + scale=1.05, + model_folders=["objaverse/condiment"], + ), + ), + corn=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.5, + ), + objaverse=dict(scale=1.05), + ), + croissant=dict( + types=("pastry"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=0.90, + ), + objaverse=dict( + scale=0.90, + ), + ), + cucumber=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.1, + ), + objaverse=dict(), + ), + cup=dict( + types=("receptacle", "stackable"), + graspable=True, + washable=True, + microwavable=True, + cookable=False, + freezable=False, + aigen=dict( + scale=1.35, + ), + objaverse=dict(), + ), + cupcake=dict( + types=("sweets"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=0.90, + ), + objaverse=dict( + exclude=[ + "cupcake_0", # can see thru bottom + "cupcake_10", # can see thru bottom, + "cupcake_1", # very small hole at bottom + ] + ), + ), + cutting_board=dict( + types=("receptacle"), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=2.0, + ), + objaverse=dict( + scale=1.35, + exclude=[ + "cutting_board_14", + "cutting_board_3", + "cutting_board_10", + "cutting_board_6", # these models still modeled with meshes which should work most of the time, but excluding them for safety + ], + ), + ), + donut=dict( + types=("sweets", "pastry"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.5, + ), + objaverse=dict( + scale=1.15, + ), + ), + egg=dict( + types=("dairy"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.15, + ), + objaverse=dict( + scale=0.85, + ), + ), + eggplant=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.30, + ), + objaverse=dict(scale=0.95), + ), + fish=dict( + types=("meat"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=[1.35, 1.35, 2.0], + ), + objaverse=dict( + scale=[1.0, 1.0, 1.5], + ), + ), + fork=dict( + types=("utensil"), + graspable=False, + washable=True, + microwavable=True, + cookable=True, + freezable=False, + aigen=dict( + scale=1.75, + ), + objaverse=dict(), + ), + garlic=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.3, + ), + objaverse=dict(scale=1.10, exclude=["garlic_3"]), # has hole on side + ), + hot_dog=dict( + types=("cooked_food"), + graspable=True, + washable=False, + microwavable=True, + cookable=False, + freezable=True, + aigen=dict( + scale=1.4, + ), + objaverse=dict(), + ), + jam=dict( + types=("packaged_food"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.05, + ), + objaverse=dict( + scale=0.90, + ), + ), + jug=dict( + types=("receptacle"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.5, + ), + objaverse=dict( + scale=1.5, + ), + ), + ketchup=dict( + types=("condiment"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.35, + ), + objaverse=dict( + exclude=[ + "ketchup_5" # causing error: faces of mesh have inconsistent orientation. + ] + ), + ), + kettle_electric=dict( + types=("receptacle"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + objaverse=dict( + scale=1.35, + model_folders=["objaverse/kettle"], + exclude=[ + f"kettle_{i}" + for i in range(29) + if i not in [0, 7, 9, 12, 13, 17, 24, 25, 26, 27] + ], + ), + aigen=dict( + scale=1.5, + model_folders=["aigen_objs/kettle"], + exclude=[f"kettle_{i}" for i in range(11) if i not in [0, 2, 6, 9, 10, 11]], + ), + ), + kettle_non_electric=dict( + types=("receptacle"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + objaverse=dict( + scale=1.35, + model_folders=["objaverse/kettle"], + exclude=[ + f"kettle_{i}" + for i in range(29) + if i in [0, 7, 9, 12, 13, 17, 24, 25, 26, 27] + ], + ), + aigen=dict( + scale=1.5, + model_folders=["aigen_objs/kettle"], + exclude=[f"kettle_{i}" for i in range(11) if i in [0, 2, 6, 9, 10, 11]], + ), + ), + kiwi=dict( + types=("fruit"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=0.90, + ), + objaverse=dict( + scale=0.90, + ), + ), + knife=dict( + types=("utensil"), + graspable=False, + washable=True, + microwavable=True, + cookable=True, + freezable=False, + aigen=dict( + scale=1.35, + ), + objaverse=dict( + scale=1.20, + ), + ), + ladle=dict( + types=("utensil"), + graspable=True, + washable=True, + microwavable=False, + cookable=True, + freezable=False, + aigen=dict( + scale=1.5, + ), + objaverse=dict( + scale=1.10, + ), + ), + lemon=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=False, + cookable=True, + freezable=True, + aigen=dict( + scale=1.1, + ), + objaverse=dict(), + ), + lime=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=False, + cookable=True, + freezable=True, + objaverse=dict( + scale=1.0, + ), + aigen=dict( + scale=0.90, + ), + ), + mango=dict( + types=("fruit"), + graspable=True, + washable=True, + microwavable=False, + cookable=True, + freezable=True, + aigen=dict( + scale=1.0, + ), + objaverse=dict( + scale=0.85, + exclude=[ + "mango_3", # one half is pitch dark + ], + ), + ), + milk=dict( + types=("dairy", "drink"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.35, + ), + objaverse=dict( + exclude=[ + "milk_6" # causing error: eigenvalues of mesh inertia violate A + B >= C + ] + ), + ), + mug=dict( + types=("receptacle", "stackable"), + graspable=True, + washable=True, + microwavable=True, + cookable=False, + freezable=False, + aigen=dict( + scale=1.3, + ), + objaverse=dict(), + ), + mushroom=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.35, + ), + objaverse=dict( + scale=1.20, + exclude=[ + # "mushroom_16", # very very small holes. keeping anyway + ], + ), + ), + onion=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=False, + aigen=dict( + scale=1.1, + ), + objaverse=dict(), + ), + orange=dict( + types=("fruit"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.05, + ), + objaverse=dict( + exclude=[ + # "orange_11", # bottom half is dark. keeping anyway + ] + ), + ), + pan=dict( + types=("receptacle"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=2.25, + ), + objaverse=dict( + scale=1.70, + exclude=[ + "pan_16", # causing error. faces of mesh have inconsistent orientation, + "pan_0", + "pan_12", + "pan_17", + "pan_22", # these are technically what we consider "pots" + ], + ), + ), + pot=dict( + types=("receptacle"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=2.25, + ), + objaverse=dict( + model_folders=["objaverse/pan"], + scale=1.70, + exclude=list( + set([f"pan_{i}" for i in range(25)]) + - set(["pan_0", "pan_12", "pan_17", "pan_22"]) + ), + ), + ), + peach=dict( + types=("fruit"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.05, + ), + objaverse=dict(), + ), + pear=dict( + types=("fruit"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict(), + objaverse=dict( + exclude=[ + "pear_4", # has big hole. excluding + ] + ), + ), + plate=dict( + types=("receptacle"), + graspable=False, + washable=True, + microwavable=True, + cookable=False, + freezable=False, + aigen=dict( + scale=1.65, + ), + objaverse=dict( + scale=1.35, + exclude=[ + "plate_6", # causing error: faces of mesh have inconsistent orientation. + ], + ), + ), + potato=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.10, + ), + objaverse=dict(), + ), + rolling_pin=dict( + types=("tool"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.6, + ), + objaverse=dict( + scale=1.25, + exclude=[ + # "rolling_pin_5", # can see thru side handle edges, keeping anyway + # "rolling_pin_1", # can see thru side handle edges, keeping anyway + ], + ), + ), + scissors=dict( + types=("tool"), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.35, + ), + objaverse=dict( + scale=1.15, + ), + ), + shaker=dict( + types=("condiment"), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.25, + ), + objaverse=dict(), + ), + soap_dispenser=dict( + types=("cleaner"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.7, + ), + objaverse=dict( + exclude=[ + # "soap_dispenser_4", # can see thru body but that's fine if this is glass + ] + ), + ), + spatula=dict( + types=("utensil"), + graspable=False, + washable=True, + microwavable=False, + cookable=True, + freezable=False, + aigen=dict( + scale=1.30, + ), + objaverse=dict( + scale=1.10, + ), + ), + sponge=dict( + types=("cleaner"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.20, + ), + objaverse=dict( + scale=0.90, + # exclude=[ + # "sponge_7", "sponge_1", # self turning due to single collision geom + # ] + ), + ), + spoon=dict( + types=("utensil"), + graspable=False, + washable=True, + microwavable=True, + cookable=True, + freezable=False, + aigen=dict( + scale=1.5, + ), + objaverse=dict(), + ), + spray=dict( + types=("cleaner"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.75, + ), + objaverse=dict( + scale=1.75, + ), + ), + squash=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=1.15, + ), + objaverse=dict( + exclude=[ + "squash_10", # hole at bottom + ], + ), + ), + steak=dict( + types=("meat"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict( + scale=[1.0, 1.0, 2.0], + ), + objaverse=dict( + scale=[1.0, 1.0, 2.0], + exclude=[ + "steak_13", # bottom texture completely messed up + "steak_1", # bottom texture completely messed up + # "steak_9", # bottom with some minor issues, keeping anyway + ], + ), + ), + sweet_potato=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + aigen=dict(), + objaverse=dict(), + ), + tangerine=dict( + types=("fruit"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict(), + objaverse=dict(), + ), + teapot=dict( + types=("receptacle"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.25, + ), + objaverse=dict( + scale=1.25, + exclude=[ + "teapot_9", # hole on bottom + ], + ), + ), + tomato=dict( + types=("vegetable"), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=False, + aigen=dict( + scale=1.25, + ), + objaverse=dict(), + ), + tray=dict( + types=("receptacle"), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict(scale=2.0), + objaverse=dict( + scale=1.80, + ), + ), + waffle=dict( + types=("sweets"), + graspable=False, + washable=False, + microwavable=True, + cookable=False, + freezable=True, + aigen=dict( + scale=1.75, + ), + objaverse=dict( + exclude=[ + "waffle_2", # bottom completely messed up + ] + ), + ), + water_bottle=dict( + types=("drink"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.6, + ), + objaverse=dict( + scale=1.5, + exclude=[ + "water_bottle_11", # sides and bottom see thru, but ok if glass. keeping anyway + ], + ), + ), + wine=dict( + types=("drink", "alcohol"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + aigen=dict( + scale=1.9, + ), + objaverse=dict( + scale=1.6, + exclude=[ + "wine_7", # causing error. faces of mesh have inconsistent orientation + ], + ), + ), + yogurt=dict( + types=("dairy", "packaged_food"), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + aigen=dict( + scale=1.0, + ), + objaverse=dict( + scale=0.95, + ), + ), + dates=dict( + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("fruit"), + aigen=dict(), + ), + lemonade=dict( + aigen=dict( + scale=1.5, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + types=("drink"), + ), + walnut=dict( + aigen=dict( + scale=1.15, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=(), + ), + cheese_grater=dict( + aigen=dict( + scale=2.15, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("tool"), + ), + syrup_bottle=dict( + aigen=dict( + scale=1.35, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + types=("condiment"), + ), + scallops=dict( + aigen=dict( + scale=1.25, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + candy=dict( + aigen=dict(), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + types=("sweets"), + ), + whisk=dict( + aigen=dict( + scale=1.8, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("utensil"), + ), + pitcher=dict( + aigen=dict( + scale=1.75, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=False, + freezable=False, + types=("receptacle"), + ), + ice_cream=dict( + aigen=dict( + scale=1.25, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + types=("sweets"), + ), + cherry=dict( + aigen=dict(), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("fruit"), + ), + peanut_butter=dict( + aigen=dict( + scale=1.25, + model_folders=["aigen_objs/peanut_butter_jar"], + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + types=("packaged_food"), + ), + thermos=dict( + aigen=dict( + scale=1.75, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=False, + freezable=True, + types=("drink"), + ), + ham=dict( + aigen=dict( + scale=1.5, + ), + graspable=False, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + dumpling=dict( + aigen=dict( + scale=1.15, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat", "cooked_food"), + ), + cabbage=dict( + aigen=dict( + scale=2.0, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=True, + freezable=True, + types=("vegetable"), + ), + lettuce=dict( + aigen=dict( + scale=2.0, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("vegetable"), + ), + tongs=dict( + aigen=dict( + scale=1.5, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("tool"), + ), + ginger=dict( + aigen=dict( + scale=1.35, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=True, + freezable=True, + types=("vegetable"), + ), + ice_cube_tray=dict( + aigen=dict( + scale=2.0, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("receptacle"), + ), + shrimp=dict( + aigen=dict( + scale=1.15, + ), + graspable=False, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + cantaloupe=dict( + aigen=dict( + scale=1.5, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("fruit"), + ), + honey_bottle=dict( + aigen=dict( + scale=1.10, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + types=("packaged_food"), + ), + grapes=dict( + aigen=dict( + scale=1.5, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("fruit"), + ), + spaghetti_box=dict( + aigen=dict( + scale=1.25, + ), + graspable=False, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + types=("packaged_food"), + ), + chili_pepper=dict( + aigen=dict( + scale=1.10, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("vegetable"), + ), + celery=dict( + aigen=dict( + scale=2.0, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("vegetable"), + ), + burrito=dict( + aigen=dict( + scale=1.35, + ), + graspable=True, + washable=False, + microwavable=True, + cookable=False, + freezable=True, + types=("cooked_food"), + ), + olive_oil_bottle=dict( + aigen=dict( + scale=1.5, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + types=("packaged_food"), + ), + kebabs=dict( + aigen=dict( + scale=1.65, + ), + graspable=True, + washable=False, + microwavable=True, + cookable=True, + freezable=True, + types=("cooked_food"), + ), + bottle_opener=dict( + aigen=dict(), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("tool"), + ), + chicken_breast=dict( + aigen=dict( + scale=1.35, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + jello_cup=dict( + aigen=dict( + scale=1.15, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + types=("packaged_food"), + ), + lobster=dict( + aigen=dict( + scale=1.15, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + brussel_sprout=dict( + aigen=dict(), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("vegetable"), + ), + sushi=dict( + aigen=dict( + scale=0.90, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=True, + types=("meat"), + ), + baking_sheet=dict( + aigen=dict( + scale=1.75, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("receptacle"), + ), + wine_glass=dict( + aigen=dict( + scale=1.5, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=False, + freezable=True, + types=("receptacle"), + ), + asparagus=dict( + aigen=dict( + scale=1.35, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("vegetable"), + ), + lamb_chop=dict( + aigen=dict( + scale=1.15, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + pickle=dict( + aigen=dict( + scale=1.0, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("vegetable"), + ), + bacon=dict( + aigen=dict( + scale=1.35, + ), + graspable=False, + washable=False, + microwavable=True, + cookable=True, + freezable=False, + types=("meat"), + ), + canola_oil=dict( + aigen=dict( + scale=1.75, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + types=("packaged_food"), + ), + strawberry=dict( + aigen=dict( + scale=0.9, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("fruit"), + ), + watermelon=dict( + aigen=dict( + scale=2.5, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("fruit"), + ), + pizza_cutter=dict( + aigen=dict( + scale=1.4, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("tool"), + ), + pomegranate=dict( + aigen=dict( + scale=1.25, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("fruit"), + ), + apricot=dict( + aigen=dict( + scale=0.7, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("fruit"), + ), + beet=dict( + aigen=dict(), + graspable=True, + washable=True, + microwavable=False, + cookable=True, + freezable=False, + types=("vegetable"), + ), + radish=dict( + aigen=dict( + scale=1.0, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("vegetable"), + ), + salsa=dict( + aigen=dict( + scale=1.15, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + types=("packaged_food"), + ), + artichoke=dict( + aigen=dict( + scale=1.35, + ), + graspable=True, + washable=True, + microwavable=False, + cookable=True, + freezable=False, + types=("vegetable"), + ), + scone=dict( + aigen=dict( + scale=1.35, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + types=("pastry", "bread_food"), + ), + hamburger=dict( + aigen=dict( + scale=1.35, + ), + graspable=True, + washable=False, + microwavable=True, + cookable=False, + freezable=False, + types=("cooked_food"), + ), + raspberry=dict( + aigen=dict( + scale=0.85, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("fruit"), + ), + tacos=dict( + aigen=dict( + scale=1.0, + ), + graspable=True, + washable=False, + microwavable=True, + cookable=False, + freezable=False, + types=("cooked_food"), + ), + vinegar=dict( + aigen=dict( + scale=1.4, + ), + graspable=True, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + types=("packaged_food", "condiment"), + ), + zucchini=dict( + aigen=dict( + scale=1.35, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("vegetable"), + ), + pork_loin=dict( + aigen=dict(), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + pork_chop=dict( + aigen=dict( + scale=1.25, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + sausage=dict( + aigen=dict( + scale=1.45, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + coconut=dict( + aigen=dict( + scale=2.0, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("fruit"), + ), + cauliflower=dict( + aigen=dict( + scale=1.5, + ), + graspable=False, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("vegetable"), + ), + lollipop=dict( + aigen=dict(), + graspable=False, + washable=False, + microwavable=False, + cookable=False, + freezable=False, + types=("sweets"), + ), + salami=dict( + aigen=dict( + scale=1.5, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=True, + types=("meat"), + ), + butter_stick=dict( + aigen=dict( + scale=1.3, + ), + graspable=True, + washable=False, + microwavable=True, + cookable=True, + freezable=True, + types=("dairy"), + ), + can_opener=dict( + aigen=dict( + scale=1.5, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=False, + types=("tool"), + ), + tofu=dict( + aigen=dict(), + graspable=True, + washable=True, + microwavable=False, + cookable=True, + freezable=True, + types=(), + ), + pineapple=dict( + aigen=dict( + scale=2.0, + ), + graspable=False, + washable=True, + microwavable=False, + cookable=False, + freezable=True, + types=("fruit"), + ), + skewers=dict( + aigen=dict( + scale=1.75, + ), + graspable=True, + washable=True, + microwavable=True, + cookable=True, + freezable=False, + types=("meat", "cooked_food"), + ), +) + + +def get_cats_by_type(types): + """ + Retrieves a list of item keys from the global `OBJ_CATEGORIES` dictionary based on the specified types. + + Args: + types (list): A list of valid types to filter items by. Only items with a matching type will be included. + + Returns: + list: A list of keys from `OBJ_CATEGORIES` where the item's types intersect with the provided `types`. + """ + types = set(types) + + res = [] + for key, val in OBJ_CATEGORIES.items(): + cat_types = val["types"] + if isinstance(cat_types, str): + cat_types = [cat_types] + cat_types = set(cat_types) + # Access the "types" key in the dictionary using the correct syntax + if len(cat_types.intersection(types)) > 0: + res.append(key) + + return res + + +### define all object categories ### +OBJ_GROUPS = dict( + all=list(OBJ_CATEGORIES.keys()), +) + +for k in OBJ_CATEGORIES: + OBJ_GROUPS[k] = [k] + +all_types = set() +# populate all_types +for (cat, cat_meta_dict) in OBJ_CATEGORIES.items(): + # types are common to both so we only need to examine one + cat_types = cat_meta_dict["types"] + if isinstance(cat_types, str): + cat_types = [cat_types] + all_types = all_types.union(cat_types) + +# populate OBJ_GROUPS which maps types to categories associated with the type +for t in all_types: + OBJ_GROUPS[t] = get_cats_by_type(types=[t]) + +OBJ_GROUPS["food"] = get_cats_by_type( + [ + "vegetable", + "fruit", + "sweets", + "dairy", + "meat", + "bread_food", + "pastry", + "cooked_food", + ] +) +OBJ_GROUPS["in_container"] = get_cats_by_type( + [ + "vegetable", + "fruit", + "sweets", + "dairy", + "meat", + "bread_food", + "pastry", + "cooked_food", + ] +) + +# custom groups +OBJ_GROUPS["container"] = ["plate"] # , "bowl"] +OBJ_GROUPS["kettle"] = ["kettle_electric", "kettle_non_electric"] +OBJ_GROUPS["cookware"] = ["pan", "pot", "kettle_non_electric"] +OBJ_GROUPS["pots_and_pans"] = ["pan", "pot"] +OBJ_GROUPS["food_set1"] = [ + "apple", + "baguette", + "banana", + "carrot", + "cheese", + "cucumber", + "egg", + "lemon", + "orange", + "potato", +] +OBJ_GROUPS["group1"] = ["apple", "carrot", "banana", "bowl", "can"] +OBJ_GROUPS["container_set2"] = ["plate", "bowl"] diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/objects.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/objects.py new file mode 100644 index 0000000000000000000000000000000000000000..0527e5504af5a9bc5ead36457c86b5187e283d79 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/objects/objects.py @@ -0,0 +1,111 @@ +import numpy as np +import sapien +from transforms3d.euler import quat2mat + +from mani_skill.utils.scene_builder.robocasa.fixtures.mujoco_object import MujocoObject +from mani_skill.utils.scene_builder.robocasa.utils.mjcf_utils import string_to_array + + +class MJCFObject(MujocoObject): + """ + Blender object with support for changing the scaling + """ + + def __init__( + self, + scene, + name, + mjcf_path, + scale=1.0, + solimp=(0.998, 0.998, 0.001), + solref=(0.001, 1), + density=100, + friction=(0.95, 0.3, 0.1), + margin=None, + rgba=None, + priority=None, + ): + # get scale in x, y, z + if isinstance(scale, float): + scale = [scale, scale, scale] + elif isinstance(scale, tuple) or isinstance(scale, list): + assert len(scale) == 3 + scale = tuple(scale) + else: + raise Exception("got invalid scale: {}".format(scale)) + scale = np.array(scale) + + # note (stao): the values below are unused atm + self.solimp = solimp + self.solref = solref + self.density = density + self.friction = friction + self.margin = margin + + self.priority = priority + + self.rgba = rgba + + super().__init__( + scene=scene, + xml=mjcf_path, + name=name, + # joints=[dict(type="free", damping="0.0005")], + # obj_type="all", + # duplicate_collision_geoms=False, + scale=scale, + ) + + def build(self, scene_idxs: list[int]): + self.actor_builder.set_scene_idxs(scene_idxs) + self.actor_builder.initial_pose = sapien.Pose(p=self.pos, q=self.quat) + self.actor = self.actor_builder.build_dynamic( + name=self.name + f"_{scene_idxs[0]}" + ) + return self + + @property + def horizontal_radius(self): + horizontal_radius_site = self.loader.xml.find( + ".//site[@name='{}horizontal_radius_site']".format(self.naming_prefix) + ) + site_values = string_to_array(horizontal_radius_site.get("pos")) + return np.linalg.norm(site_values[0:2]) + + def get_bbox_points(self, trans=None, rot=None): + """ + Get the full 8 bounding box points of the object + rot: a rotation matrix + """ + bbox_offsets = [] + + bottom_offset = self.bottom_offset + top_offset = self.top_offset + horizontal_radius_site = self.loader.xml.find( + ".//site[@name='{}horizontal_radius_site']".format(self.naming_prefix) + ) + horiz_radius = string_to_array(horizontal_radius_site.get("pos"))[:2] + + center = np.mean([bottom_offset, top_offset], axis=0) + half_size = [horiz_radius[0], horiz_radius[1], top_offset[2] - center[2]] + + bbox_offsets = [ + center + half_size * np.array([-1, -1, -1]), # p0 + center + half_size * np.array([1, -1, -1]), # px + center + half_size * np.array([-1, 1, -1]), # py + center + half_size * np.array([-1, -1, 1]), # pz + center + half_size * np.array([1, 1, 1]), + center + half_size * np.array([-1, 1, 1]), + center + half_size * np.array([1, -1, 1]), + center + half_size * np.array([1, 1, -1]), + ] + + if trans is None: + trans = np.array([0, 0, 0]) + if rot is not None: + rot = quat2mat(rot) + else: + rot = np.eye(3) + + points = [(np.matmul(rot, p) + trans) for p in bbox_offsets] + return points diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/scene_builder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/scene_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..cbe841be4c121a963e926e4f2e3cd3567084d3ea --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/scene_builder.py @@ -0,0 +1,961 @@ +"""Implementation of the RoboCasa scene builder. Code ported from https://github.com/robocasa/robocasa""" + +import logging +from copy import deepcopy +from typing import Dict, List, Optional + +import numpy as np +import torch +import yaml +from transforms3d.euler import euler2quat + +from mani_skill.utils.scene_builder.robocasa.fixtures.accessories import ( + Accessory, + CoffeeMachine, + Stool, + Toaster, + WallAccessory, +) +from mani_skill.utils.scene_builder.robocasa.fixtures.cabinet import ( + Drawer, + HingeCabinet, + HousingCabinet, + OpenCabinet, + PanelCabinet, + SingleCabinet, +) +from mani_skill.utils.scene_builder.robocasa.fixtures.counter import Counter +from mani_skill.utils.scene_builder.robocasa.fixtures.dishwasher import Dishwasher +from mani_skill.utils.scene_builder.robocasa.fixtures.fixture import ( + Fixture, + FixtureType, +) +from mani_skill.utils.scene_builder.robocasa.fixtures.fixture_stack import FixtureStack +from mani_skill.utils.scene_builder.robocasa.fixtures.fixture_utils import ( + fixture_is_type, +) +from mani_skill.utils.scene_builder.robocasa.fixtures.fridge import Fridge +from mani_skill.utils.scene_builder.robocasa.fixtures.hood import Hood +from mani_skill.utils.scene_builder.robocasa.fixtures.microwave import Microwave +from mani_skill.utils.scene_builder.robocasa.fixtures.others import Box, Floor, Wall +from mani_skill.utils.scene_builder.robocasa.fixtures.sink import Sink +from mani_skill.utils.scene_builder.robocasa.fixtures.stove import Oven, Stove, Stovetop +from mani_skill.utils.scene_builder.robocasa.fixtures.windows import ( + FramedWindow, + Window, +) +from mani_skill.utils.scene_builder.robocasa.utils import object_utils as OU +from mani_skill.utils.scene_builder.robocasa.utils import scene_registry, scene_utils +from mani_skill.utils.scene_builder.robocasa.utils.placement_samplers import ( + RandomizationError, + SequentialCompositeSampler, + UniformRandomSampler, +) +from mani_skill.utils.scene_builder.scene_builder import SceneBuilder +from mani_skill.utils.structs import Actor +from mani_skill.utils.structs.pose import Pose + +FIXTURES = dict( + hinge_cabinet=HingeCabinet, + single_cabinet=SingleCabinet, + open_cabinet=OpenCabinet, + panel_cabinet=PanelCabinet, + housing_cabinet=HousingCabinet, + drawer=Drawer, + counter=Counter, + stove=Stove, + stovetop=Stovetop, + oven=Oven, + microwave=Microwave, + hood=Hood, + sink=Sink, + fridge=Fridge, + dishwasher=Dishwasher, + wall=Wall, + floor=Floor, + box=Box, + accessory=Accessory, + paper_towel=Accessory, + plant=Accessory, + knife_block=Accessory, + stool=Stool, + utensil_holder=Accessory, + coffee_machine=CoffeeMachine, + toaster=Toaster, + utensil_rack=WallAccessory, + wall_accessory=WallAccessory, + window=Window, + framed_window=FramedWindow, + # needs some additional work + # slide_cabinet=SlideCabinet, +) +# fixtures that are attached to other fixtures, disables positioning system in this script +FIXTURES_INTERIOR = dict( + sink=Sink, stovetop=Stovetop, accessory=Accessory, wall_accessory=WallAccessory +) + +ALL_SIDES = ["left", "right", "front", "back", "bottom", "top"] + +ROBOT_FRONT_FACING_SIZE = dict(fetch=0.8, unitree_g1_simplified_upper_body=0.6) + + +def check_syntax(fixture): + """ + Checks that specifications of a fixture follows syntax rules + """ + + if fixture["type"] != "stack" and fixture["type"] not in FIXTURES: + raise ValueError( + 'Invalid value for fixture type: "{}".'.format(fixture["type"]) + ) + + if "config_name" in fixture and "default_config_name" in fixture: + raise ValueError('Cannot specify both "config_name" and "default_config_name"') + + if "align_to" in fixture or "side" in fixture or "alignment" in fixture: + if not ("align_to" in fixture and "side" in fixture): + raise ValueError( + 'Both or neither of "align_to" and ' '"side" need to be specified.' + ) + if "pos" in fixture: + raise ValueError("Cannot specify both relative and absolute positions.") + + # check alignment and side arguments are compatible + if "alignment" in fixture: + for keywords in scene_utils.AXES_KEYWORDS.values(): + if fixture["side"] in keywords: + # check that neither keyword is used for alignment + if ( + keywords[0] in fixture["alignment"] + or keywords[1] in fixture["alignment"] + ): + raise ValueError( + 'Cannot set alignment to "{}" when aligning to the "{}" side'.format( + fixture["alignment"], fixture["side"] + ) + ) + + # check if side is valid + if fixture["side"] not in ALL_SIDES: + raise ValueError( + '"{}" is not a valid side for alignment'.format(fixture["side"]) + ) + + +class RoboCasaSceneBuilder(SceneBuilder): + """ + SceneBuilder for the RoboCasa dataset: https://github.com/robocasa/robocasa + + TODO explain build config idxs and init config idxs + """ + + def __init__(self, *args, init_robot_base_pos=None, **kwargs): + self.init_robot_base_pos = init_robot_base_pos + self.scene_data = [] # maps scene_idx to {"fixtures", "fxtr_placements"} + super().__init__(*args, **kwargs) + + def build(self, build_config_idxs: Optional[List[int]] = None): + if self.env.agent is not None: + self.robot_poses = self.env.agent.robot.initial_pose + else: + self.robot_poses = None + if build_config_idxs is None: + build_config_idxs = [] + for i in range(self.env.num_envs): + # Total number of configs is 10 * 12 = 120 + config_idx = self.env._batched_episode_rng[i].randint(0, 120) + build_config_idxs.append(config_idx) + + for scene_idx, build_config_idx in enumerate(build_config_idxs): + layout_idx = build_config_idx // 12 # Get layout index (0-9) + style_idx = build_config_idx % 12 # Get style index (0-11) + layout_path = scene_registry.get_layout_path(layout_idx) + style_path = scene_registry.get_style_path(style_idx) + # load style + with open(style_path, "r") as f: + style = yaml.safe_load(f) + + # load arena + with open(layout_path, "r") as f: + arena_config = yaml.safe_load(f) + + # contains all fixtures with updated configs + arena = list() + + # Update each fixture config. First iterate through groups: subparts of the arena that can be + # rotated and displaced together. example: island group, right group, room group, etc + for group_name, group_config in arena_config.items(): + group_fixtures = list() + # each group is further divded into similar subcollections of fixtures + # ex: main group counter accessories, main group top cabinets, etc + for k, fixture_list in group_config.items(): + # these values are rotations/displacements that are applied to all fixtures in the group + if k in ["group_origin", "group_z_rot", "group_pos"]: + continue + elif type(fixture_list) != list: + raise ValueError( + '"{}" is not a valid argument for groups'.format(k) + ) + + # add suffix to support different groups + for fxtr_config in fixture_list: + fxtr_config["name"] += "_" + group_name + # update fixture names for alignment, interior objects, etc. + for k in scene_utils.ATTACH_ARGS + [ + "align_to", + "stack_fixtures", + "size", + ]: + if k in fxtr_config: + if isinstance(fxtr_config[k], list): + for i in range(len(fxtr_config[k])): + if isinstance(fxtr_config[k][i], str): + fxtr_config[k][i] += "_" + group_name + else: + if isinstance(fxtr_config[k], str): + fxtr_config[k] += "_" + group_name + + group_fixtures.extend(fixture_list) + + # update group rotation/displacement if necessary + if "group_origin" in group_config: + for fxtr_config in group_fixtures: + # do not update the rotation of the walls/floor + if fxtr_config["type"] in ["wall", "floor"]: + continue + fxtr_config["group_origin"] = group_config["group_origin"] + fxtr_config["group_pos"] = group_config["group_pos"] + fxtr_config["group_z_rot"] = group_config["group_z_rot"] + + # addto overall fixture list + arena.extend(group_fixtures) + + # maps each fixture name to its object class + fixtures: Dict[str, Fixture] = dict() + # maps each fixture name to its configuration + configs = dict() + # names of composites, delete from fixtures before returning + composites = list() + + for fixture_config in arena: + # scene_registry.check_syntax(fixture_config) + fixture_name = fixture_config["name"] + + # stack of fixtures, handled separately + if fixture_config["type"] == "stack": + stack = FixtureStack( + self.scene, + fixture_config, + fixtures, + configs, + style, + default_texture=None, + rng=self.env._batched_episode_rng[scene_idx], + ) + fixtures[fixture_name] = stack + configs[fixture_name] = fixture_config + composites.append(fixture_name) + continue + + # load style information and update config to include it + default_config = scene_utils.load_style_config(style, fixture_config) + if default_config is not None: + for k, v in fixture_config.items(): + default_config[k] = v + fixture_config = default_config + + # set fixture type + if fixture_config["type"] not in FIXTURES: + continue + fixture_config["type"] = FIXTURES[fixture_config["type"]] + + # pre-processing for fixture size + size = fixture_config.get("size", None) + if isinstance(size, list): + for i in range(len(size)): + elem = size[i] + if isinstance(elem, str): + ref_fxtr = fixtures[elem] + size[i] = ref_fxtr.size[i] + + # initialize fixture + # TODO (stao): use batched episode rng later + fixture = scene_utils.initialize_fixture( + self.scene, + fixture_config, + fixtures, + rng=self.env._batched_episode_rng[scene_idx], + ) + + fixtures[fixture_name] = fixture + configs[fixture_name] = fixture_config + pos = None + # update fixture position + if fixture_config["type"] not in FIXTURES_INTERIOR.values(): + # relative positioning + if "align_to" in fixture_config: + pos = scene_utils.get_relative_position( + fixture, + fixture_config, + fixtures[fixture_config["align_to"]], + configs[fixture_config["align_to"]], + ) + + elif "stack_on" in fixture_config: + stack_on = fixtures[fixture_config["stack_on"]] + + # account for off-centered objects + stack_on_center = stack_on.center + + # infer unspecified axes of position + pos = fixture_config["pos"] + if pos[0] is None: + pos[0] = stack_on.pos[0] + stack_on_center[0] + if pos[1] is None: + pos[1] = stack_on.pos[1] + stack_on_center[1] + + # calculate height of fixture + pos[2] = ( + stack_on.pos[2] + stack_on.size[2] / 2 + fixture.size[2] / 2 + ) + pos[2] += stack_on_center[2] + else: + # absolute position + pos = fixture_config.get("pos", None) + if pos is not None and type(fixture) not in [Wall, Floor]: + fixture.set_pos(deepcopy(pos)) + # composites are non-MujocoObjects, must remove + for composite in composites: + del fixtures[composite] + + # update the rotation and postion of each fixture based on their group + for name, fixture in fixtures.items(): + # check if updates are necessary + config = configs[name] + if "group_origin" not in config: + continue + + # TODO: add default for group origin? + # rotate about this coordinate (around the z-axis) + origin = config["group_origin"] + pos = config["group_pos"] + z_rot = config["group_z_rot"] + displacement = [pos[0] - origin[0], pos[1] - origin[1]] + + if type(fixture) not in [Wall, Floor]: + dx = fixture.pos[0] - origin[0] + dy = fixture.pos[1] - origin[1] + dx_rot = dx * np.cos(z_rot) - dy * np.sin(z_rot) + dy_rot = dx * np.sin(z_rot) + dy * np.cos(z_rot) + + x_rot = origin[0] + dx_rot + y_rot = origin[1] + dy_rot + z = fixture.pos[2] + pos_new = [x_rot + displacement[0], y_rot + displacement[1], z] + + # account for previous z-axis rotation + rot_prev = fixture.euler + if rot_prev is not None: + # TODO: switch to quaternion since euler rotations are ambiguous + rot_new = rot_prev + rot_new[2] += z_rot + else: + rot_new = [0, 0, z_rot] + fixture.pos = np.array(pos_new) + fixture.set_euler(rot_new) + + # self.actors = actors + # fixtures = fixtures + fixture_cfgs = self.get_fixture_cfgs(fixtures) + # generate initial poses for objects so that they are spawned in nice places during GPU initialization + # to be more performant + ( + fxtr_placements, + robot_base_pos, + robot_base_ori, + ) = self._generate_initial_placements( + fixtures, fixture_cfgs, rng=self.env._batched_episode_rng[scene_idx] + ) + self.scene_data.append( + dict( + fixtures=fixtures, + fxtr_placements=fxtr_placements, + fixture_cfgs=fixture_cfgs, + ) + ) + + # Loop through all objects and reset their positions + for obj_pos, obj_quat, obj in fxtr_placements.values(): + assert isinstance(obj, Fixture) + obj.pos = obj_pos + obj.quat = obj_quat + + if self.env.agent is not None: + self.robot_poses.raw_pose[scene_idx][:3] = torch.from_numpy( + robot_base_pos + ).to(self.robot_poses.device) + self.robot_poses.raw_pose[scene_idx][3:] = torch.from_numpy( + euler2quat(*robot_base_ori) + ).to(self.robot_poses.device) + + actors: Dict[str, Actor] = {} + + ### collision handling and optimization ### + # Generally we aim to ensure all articulations in a stack have the same collision bits so they can't collide with each other + # and with a range of [22, 30] we can generally ensure adjacent articulations can collide with each other. + # walls and floors cannot collide with anything. Walls can only collide with the robot. They are assigned bits 22 to 30. + # mobile base robots have their wheels/non base links assigned bit of 30 to not collide with the floor or walls. + # the base links can optionally be also assigned a bit of 31 to not collide with walls. + + # fixtures that are not articulated are always static and cannot hit other non-articulated fixtures. This scenario is assigned bit 21. + actor_bit = 21 + # prismatic_drawer_bit = 25 + + collision_start_bit = 22 + fixture_idx = 0 + stack_collision_bits = dict() + for stack_index, stack in enumerate(composites): + stack_collision_bits[stack] = collision_start_bit + stack_index % 9 + for k, v in fixtures.items(): + fixture_idx += 1 + built = v.build(scene_idxs=[scene_idx]) + if built is not None: + actors[k] = built + # ensure all rooted articulated objects have collisions ignored with all static objects + # ensure all articulations in the same stack have the same collision bits, since by definition for robocasa they cannot + # collide with each other + if ( + built.is_articulation + and built.articulation.fixed_root_link.all() + ): + collision_bit = collision_start_bit + fixture_idx % 5 + if "stack" in v.name: + for stack_group in stack_collision_bits.keys(): + if stack_group in v.name: + collision_bit = stack_collision_bits[stack_group] + break + # is_prismatic_cabinet = False + # for joint in built.articulation.joints: + # if joint.type[0] == "prismatic": + # is_prismatic_cabinet = True + # break + for link in built.articulation.links: + # if "object" in link.name: + # import ipdb; ipdb.set_trace() + link.set_collision_group( + group=2, value=0 + ) # clear all default ignored collisions + if link.joint.type[0] == "fixed": + link.set_collision_group_bit( + group=2, bit_idx=actor_bit, bit=1 + ) + link.set_collision_group_bit( + group=2, bit_idx=collision_bit, bit=1 + ) + + else: + if built.actor.px_body_type == "static": + collision_bit = collision_start_bit + fixture_idx % 5 + if "stack" in v.name: + for stack_group in stack_collision_bits.keys(): + if stack_group in v.name: + collision_bit = stack_collision_bits[ + stack_group + ] + break + if isinstance(v, Floor): + for bit_idx in range(21, 32): + built.actor.set_collision_group_bit( + group=2, bit_idx=bit_idx, bit=1 + ) + elif isinstance(v, Wall): + for bit_idx in range(21, 31): + built.actor.set_collision_group_bit( + group=2, bit_idx=bit_idx, bit=1 + ) + + else: + built.actor.set_collision_group_bit( + group=2, + bit_idx=collision_bit, + bit=1, + ) + built.actor.set_collision_group_bit( + group=2, bit_idx=actor_bit, bit=1 + ) + # self.actors = actors + + # disable collisions + + if self.env.robot_uids == "fetch": + self.env.agent + for link in [self.env.agent.l_wheel_link, self.env.agent.r_wheel_link]: + for bit_idx in range(25, 31): + link.set_collision_group_bit(group=2, bit_idx=bit_idx, bit=1) + # for bit_idx in range(25, 31): + self.env.agent.base_link.set_collision_group_bit(group=2, bit_idx=31, bit=1) + + elif self.env.robot_uids == "unitree_g1_simplified_upper_body": + # TODO (stao): determine collisions to disable for unitree robot + pass + + def _generate_initial_placements( + self, fixtures, fixture_cfgs, rng: np.random.RandomState + ): + """Generate and places randomized fixtures and robot(s) into the scene. This code is not parallelized""" + fxtr_placement_initializer = self._get_placement_initializer( + fixtures, dict(), fixture_cfgs, z_offset=0.0, rng=rng + ) + fxtr_placements = None + for i in range(10): + try: + fxtr_placements = fxtr_placement_initializer.sample() + except RandomizationError: + # if macros.VERBOSE: + # print("Ranomization error in initial placement. Try #{}".format(i)) + continue + break + if fxtr_placements is None: + # if macros.VERBOSE: + # print("Could not place fixtures.") + # self._load_model() + raise RuntimeError("Could not place fixtures.") + + # setup internal references related to fixtures + # self._setup_kitchen_references() + + # set robot position + if self.init_robot_base_pos is not None: + ref_fixture = self.get_fixture(fixtures, self.init_robot_base_pos) + else: + valid_src_fixture_classes = [ + "CoffeeMachine", + "Toaster", + "Stove", + "Stovetop", + "SingleCabinet", + "HingeCabinet", + "OpenCabinet", + "Drawer", + "Microwave", + "Sink", + "Hood", + "Oven", + "Fridge", + "Dishwasher", + ] + while True: + ref_fixture = rng.choice(list(fixtures.values())) + fxtr_class = type(ref_fixture).__name__ + if fxtr_class not in valid_src_fixture_classes: + continue + break + + if self.env.agent is not None: + robot_base_pos, robot_base_ori = self.compute_robot_base_placement_pose( + fixtures, ref_fixture + ) + else: + robot_base_pos = None + robot_base_ori = None + return fxtr_placements, robot_base_pos, robot_base_ori + + def initialize(self, env_idx: torch.Tensor, init_config_idxs: List[int] = None): + with torch.device(self.env.device): + if self.env.agent is not None: + if self.env.robot_uids == "fetch": + self.env.agent.robot.set_qpos(self.env.agent.keyframes["rest"].qpos) + self.env.agent.robot.set_pose(self.robot_poses[env_idx]) + elif self.env.robot_uids == "unitree_g1_simplified_upper_body": + self.env.agent.robot.set_qpos( + self.env.agent.keyframes["standing"].qpos + ) + xyz = self.env.agent.robot.pose.p + xyz[:, 2] += self.env.agent.keyframes["standing"].pose.p[2] + self.env.agent.robot.set_pose( + Pose.create_from_pq(p=xyz, q=self.env.agent.robot.pose.q) + ) + + def get_fixture_cfgs(self, fixtures): + """ + Returns config data for all fixtures in the arena + + Returns: + list: list of fixture configurations + """ + fixture_cfgs = [] + for (name, fxtr) in fixtures.items(): + cfg = {} + cfg["name"] = name + cfg["model"] = fxtr + cfg["type"] = "fixture" + if hasattr(fxtr, "_placement"): + cfg["placement"] = fxtr._placement + + fixture_cfgs.append(cfg) + + return fixture_cfgs + + def _is_fxtr_valid(self, fxtr, size): + """ + checks if counter is valid for object placement by making sure it is large enough + + Args: + fxtr (Fixture): fixture to check + size (tuple): minimum size (x,y) that the counter region must be to be valid + + Returns: + bool: True if fixture is valid, False otherwise + """ + return True + for region in fxtr.get_reset_regions(self).values(): + if region["size"][0] >= size[0] and region["size"][1] >= size[1]: + return True + return False + + def get_fixture(self, fixtures, id, ref=None, size=(0.2, 0.2)): + """ + search fixture by id (name, object, or type) + + Args: + id (str, Fixture, FixtureType): id of fixture to search for + + ref (str, Fixture, FixtureType): if specified, will search for fixture close to ref (within 0.10m) + + size (tuple): if sampling counter, minimum size (x,y) that the counter region must be + + Returns: + Fixture: fixture object + """ + # case 1: id refers to fixture object directly + if isinstance(id, Fixture): + return id + # case 2: id refers to exact name of fixture + elif id in fixtures.keys(): + return fixtures[id] + + if ref is None: + # find all fixtures with names containing given name + if isinstance(id, FixtureType) or isinstance(id, int): + matches = [ + name + for (name, fxtr) in fixtures.items() + if fixture_is_type(fxtr, id) + ] + else: + matches = [name for name in fixtures.keys() if id in name] + if id == FixtureType.COUNTER or id == FixtureType.COUNTER_NON_CORNER: + matches = [ + name + for name in matches + if self._is_fxtr_valid(fixtures[name], size) + ] + assert len(matches) > 0 + # sample random key + # TODO (stao): fix the key! + key = self.env._episode_rng.choice(matches) + return fixtures[key] + else: + ref_fixture = self.get_fixture(fixtures, ref) + + assert isinstance(id, FixtureType) + cand_fixtures = [] + for fxtr in fixtures.values(): + if not fixture_is_type(fxtr, id): + continue + if fxtr is ref_fixture: + continue + if id == FixtureType.COUNTER: + fxtr_is_valid = self._is_fxtr_valid(fxtr, size) + if not fxtr_is_valid: + continue + cand_fixtures.append(fxtr) + + # first, try to find fixture "containing" the reference fixture + for fxtr in cand_fixtures: + if OU.point_in_fixture(ref_fixture.pos, fxtr, only_2d=True): + return fxtr + # if no fixture contains reference fixture, sample all close fixtures + dists = [ + OU.fixture_pairwise_dist(ref_fixture, fxtr) for fxtr in cand_fixtures + ] + min_dist = np.min(dists) + close_fixtures = [ + fxtr for (fxtr, d) in zip(cand_fixtures, dists) if d - min_dist < 0.10 + ] + return self.rng.choice(close_fixtures) + + def compute_robot_base_placement_pose(self, fixtures, ref_fixture, offset=None): + """ + steps: + 1. find the nearest counter to this fixture + 2. compute offset relative to this counter + 3. transform offset to global coordinates + + Args: + ref_fixture (Fixture): reference fixture to place th robot near + + offset (list): offset to add to the base position + + """ + # step 1: find vase fixture closest to robot + base_fixture = None + + # get all base fixtures in the environment + base_fixtures = [ + fxtr + for fxtr in fixtures.values() + if isinstance(fxtr, Counter) + or isinstance(fxtr, Stove) + or isinstance(fxtr, Stovetop) + or isinstance(fxtr, HousingCabinet) + or isinstance(fxtr, Fridge) + ] + + for fxtr in base_fixtures: + # get bounds of fixture + point = ref_fixture.pos + if not OU.point_in_fixture(point=point, fixture=fxtr, only_2d=True): + continue + base_fixture = fxtr + break + + # set the base fixture as the ref fixture itself if cannot find fixture containing ref + if base_fixture is None: + base_fixture = ref_fixture + # assert base_fixture is not None + + # step 2: compute offset relative to this counter + base_to_ref, _ = OU.get_rel_transform(base_fixture, ref_fixture) + cntr_y = base_fixture.get_ext_sites(relative=True)[0][1] + if self.env.agent.robot.name in ROBOT_FRONT_FACING_SIZE: + front_face_size = ROBOT_FRONT_FACING_SIZE[self.env.agent.robot.name] + else: + logging.warning( + f"Robot {self.env.agent.robot.name} doesn't have a defined front facing size, defaulting to 0.7m" + ) + front_face_size = 0.7 + base_to_edge = [ + base_to_ref[0], + cntr_y - front_face_size, + 0, + ] + if offset is not None: + base_to_edge[0] += offset[0] + base_to_edge[1] += offset[1] + + if ( + isinstance(base_fixture, HousingCabinet) + or isinstance(base_fixture, Fridge) + or "stack" in base_fixture.name + ): + base_to_edge[1] -= 0.10 + + # step 3: transform offset to global coordinates + robot_base_pos = np.zeros(3) + robot_base_pos[0:2] = OU.get_pos_after_rel_offset(base_fixture, base_to_edge)[ + 0:2 + ] + robot_base_ori = np.array([0, 0, base_fixture.rot + np.pi / 2]) + + return robot_base_pos, robot_base_ori + + def _get_placement_initializer( + self, + fixtures, + objects, + cfg_list, + z_offset=0.01, + rng: np.random.RandomState = None, + ): + + """ + Creates a placement initializer for the objects/fixtures based on the specifications in the configurations list + + Args: + cfg_list (list): list of object configurations + + z_offset (float): offset in z direction + + Returns: + SequentialCompositeSampler: placement initializer + + """ + + placement_initializer = SequentialCompositeSampler(name="SceneSampler", rng=rng) + + for (obj_i, cfg) in enumerate(cfg_list): + # determine which object is being placed + if cfg["type"] == "fixture": + mj_obj = fixtures[cfg["name"]] + elif cfg["type"] == "object": + mj_obj = objects[cfg["name"]] + else: + raise ValueError + placement = cfg.get("placement", None) + if placement is None: + continue + fixture_id = placement.get("fixture", None) + if fixture_id is not None: + # get fixture to place object on + fixture = self.get_fixture( + fixtures, + id=fixture_id, + ref=placement.get("ref", None), + ) + + # calculate the total available space where object could be placed + sample_region_kwargs = placement.get("sample_region_kwargs", {}) + + reset_region = fixture.sample_reset_region( + env=self, fixtures=fixtures, **sample_region_kwargs + ) + outer_size = reset_region["size"] + margin = placement.get("margin", 0.04) + outer_size = (outer_size[0] - margin, outer_size[1] - margin) + + # calculate the size of the inner region where object will actually be placed + target_size = placement.get("size", None) + if target_size is not None: + target_size = deepcopy(list(target_size)) + for size_dim in [0, 1]: + if target_size[size_dim] == "obj": + target_size[size_dim] = mj_obj.size[size_dim] + 0.005 + if target_size[size_dim] == "obj.x": + target_size[size_dim] = mj_obj.size[0] + 0.005 + if target_size[size_dim] == "obj.y": + target_size[size_dim] = mj_obj.size[1] + 0.005 + inner_size = np.min((outer_size, target_size), axis=0) + else: + inner_size = outer_size + + inner_xpos, inner_ypos = placement.get("pos", (None, None)) + offset = placement.get("offset", (0.0, 0.0)) + + # center inner region within outer region + if inner_xpos == "ref": + # compute optimal placement of inner region to match up with the reference fixture + x_halfsize = outer_size[0] / 2 - inner_size[0] / 2 + if x_halfsize == 0.0: + inner_xpos = 0.0 + else: + ref_fixture = self.get_fixture( + fixtures, placement["sample_region_kwargs"]["ref"] + ) + ref_pos = ref_fixture.pos + fixture_to_ref = OU.get_rel_transform(fixture, ref_fixture)[0] + outer_to_ref = fixture_to_ref - reset_region["offset"] + inner_xpos = outer_to_ref[0] / x_halfsize + inner_xpos = np.clip(inner_xpos, a_min=-1.0, a_max=1.0) + elif inner_xpos is None: + inner_xpos = 0.0 + + if inner_ypos is None: + inner_ypos = 0.0 + # offset for inner region + intra_offset = ( + (outer_size[0] / 2 - inner_size[0] / 2) * inner_xpos + offset[0], + (outer_size[1] / 2 - inner_size[1] / 2) * inner_ypos + offset[1], + ) + # center surface point of entire region + ref_pos = fixture.pos + [0, 0, reset_region["offset"][2]] + ref_rot = fixture.rot + + # x, y, and rotational ranges for randomization + x_range = ( + np.array([-inner_size[0] / 2, inner_size[0] / 2]) + + reset_region["offset"][0] + + intra_offset[0] + ) + y_range = ( + np.array([-inner_size[1] / 2, inner_size[1] / 2]) + + reset_region["offset"][1] + + intra_offset[1] + ) + rotation = placement.get("rotation", np.array([-np.pi / 4, np.pi / 4])) + else: + target_size = placement.get("size", None) + x_range = np.array([-target_size[0] / 2, target_size[0] / 2]) + y_range = np.array([-target_size[1] / 2, target_size[1] / 2]) + rotation = placement.get("rotation", np.array([-np.pi / 4, np.pi / 4])) + ref_pos = [0, 0, 0] + ref_rot = 0.0 + + # if macros.SHOW_SITES is True: + # """ + # show outer reset region + # """ + # pos_to_vis = deepcopy(ref_pos) + # pos_to_vis[:2] += T.rotate_2d_point( + # [reset_region["offset"][0], reset_region["offset"][1]], rot=ref_rot + # ) + # size_to_vis = np.concatenate( + # [ + # np.abs( + # T.rotate_2d_point( + # [outer_size[0] / 2, outer_size[1] / 2], rot=ref_rot + # ) + # ), + # [0.001], + # ] + # ) + # site_str = """""".format( + # pos=array_to_string(pos_to_vis), + # size=array_to_string(size_to_vis), + # postfix=str(obj_i), + # ) + # site_tree = ET.fromstring(site_str) + # self.model.worldbody.append(site_tree) + + # """ + # show inner reset region + # """ + # pos_to_vis = deepcopy(ref_pos) + # pos_to_vis[:2] += T.rotate_2d_point( + # [np.mean(x_range), np.mean(y_range)], rot=ref_rot + # ) + # size_to_vis = np.concatenate( + # [ + # np.abs( + # T.rotate_2d_point( + # [ + # (x_range[1] - x_range[0]) / 2, + # (y_range[1] - y_range[0]) / 2, + # ], + # rot=ref_rot, + # ) + # ), + # [0.002], + # ] + # ) + # site_str = """""".format( + # pos=array_to_string(pos_to_vis), + # size=array_to_string(size_to_vis), + # postfix=str(obj_i), + # ) + # site_tree = ET.fromstring(site_str) + # self.model.worldbody.append(site_tree) + + placement_initializer.append_sampler( + sampler=UniformRandomSampler( + name="{}_Sampler".format(cfg["name"]), + mujoco_objects=mj_obj, + x_range=x_range, + y_range=y_range, + rotation=rotation, + ensure_object_boundary_in_range=placement.get( + "ensure_object_boundary_in_range", True + ), + ensure_valid_placement=placement.get( + "ensure_valid_placement", True + ), + reference_pos=ref_pos, + reference_rot=ref_rot, + z_offset=z_offset, + rng=rng, + rotation_axis=placement.get("rotation_axis", "z"), + ), + sample_args=placement.get("sample_args", None), + ) + + return placement_initializer diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/mjcf_utils.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/mjcf_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..416a04270b9f593a494ea2fe3622b590b36feb7a Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/mjcf_utils.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/object_utils.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/object_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..34a3beae934af03af7371f46fd685833a84bcf6e Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/object_utils.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/placement_samplers.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/placement_samplers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47c73ff11c17633d347bd503f7f52843c9dd1703 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/placement_samplers.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/scene_registry.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/scene_registry.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c013219ee22089ea7b6ef76ef5593ea29bdf9fe9 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/scene_registry.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/scene_utils.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/scene_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..57d440d760edecaa2c48b31a9fd40082316e83d6 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/__pycache__/scene_utils.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/mjcf_utils.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/mjcf_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..275ee89125547b28e5ccffe3918933f654e74a1f --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/mjcf_utils.py @@ -0,0 +1,79 @@ +from copy import deepcopy + +import numpy as np + + +def string_to_array(string): + """ + Converts a array string in mujoco xml to np.array. + + Examples: + "0 1 2" => [0, 1, 2] + + Args: + string (str): String to convert to an array + + Returns: + np.array: Numerical array equivalent of @string + """ + return np.array( + [float(x) if x != "None" else None for x in string.strip().split(" ")] + ) + + +def find_elements(root, tags, attribs=None, return_first=True): + """ + Find all element(s) matching the requested @tag and @attributes. If @return_first is True, then will return the + first element found matching the criteria specified. Otherwise, will return a list of elements that match the + criteria. + + Args: + root (ET.Element): Root of the xml element tree to start recursively searching through. + tags (str or list of str or set): Tag(s) to search for in this ElementTree. + attribs (None or dict of str): Element attribute(s) to check against for a filtered element. A match is + considered found only if all attributes match. Each attribute key should have a corresponding value with + which to compare against. + return_first (bool): Whether to immediately return once the first matching element is found. + + Returns: + None or ET.Element or list of ET.Element: Matching element(s) found. Returns None if there was no match. + """ + # Initialize return value + elements = None if return_first else [] + + # Make sure tags is list + tags = [tags] if type(tags) is str else tags + + # Check the current element for matching conditions + if root.tag in tags: + matching = True + if attribs is not None: + for k, v in attribs.items(): + if root.get(k) != v: + matching = False + break + # If all criteria were matched, add this to the solution (or return immediately if specified) + if matching: + if return_first: + return root + else: + elements.append(root) + # Continue recursively searching through the element tree + for r in root: + if return_first: + elements = find_elements( + tags=tags, attribs=attribs, root=r, return_first=return_first + ) + if elements is not None: + return elements + else: + found_elements = find_elements( + tags=tags, attribs=attribs, root=r, return_first=return_first + ) + deepcopy(elements) + if found_elements: + elements += ( + found_elements if type(found_elements) is list else [found_elements] + ) + + return elements if elements else None diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/object_utils.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/object_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d70838ea10c700dcf9a8dd6565cb5ca50258f8cc --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/object_utils.py @@ -0,0 +1,189 @@ +import numpy as np +from transforms3d.euler import euler2mat + + +def get_rel_transform(fixture_A, fixture_B): + """ + Gets fixture_B's position and rotation relative to fixture_A's frame + """ + A_trans = np.array(fixture_A.pos) + B_trans = np.array(fixture_B.pos) + + # A_rot = np.array([0, 0, fixture_A.rot]) + # B_rot = np.array([0, 0, fixture_B.rot]) + + A_mat = euler2mat(0, 0, fixture_A.rot) + B_mat = euler2mat(0, 0, fixture_B.rot) + + T_WA = np.vstack((np.hstack((A_mat, A_trans[:, None])), [0, 0, 0, 1])) + T_WB = np.vstack((np.hstack((B_mat, B_trans[:, None])), [0, 0, 0, 1])) + + T_AB = np.matmul(np.linalg.inv(T_WA), T_WB) + + return T_AB[:3, 3], T_AB[:3, :3] + + +def get_fixture_to_point_rel_offset(fixture, point): + """ + get offset relative to fixture's frame, given a global point + """ + global_offset = point - fixture.pos + T_WF = euler2mat(0, 0, fixture.rot) + rel_offset = np.matmul(np.linalg.inv(T_WF), global_offset) + return rel_offset + + +def get_pos_after_rel_offset(fixture, offset): + """ + get global position of a fixture, after applying offset relative to center of fixture + """ + fixture_mat = euler2mat(0, 0, fixture.rot) + + return fixture.pos + np.dot(fixture_mat, offset) + + +def obj_in_region( + obj, + obj_pos, + obj_quat, + p0, + px, + py, + pz=None, +): + """ + check if object is in the region defined by the points. + Uses either the objects bounding box or the object's horizontal radius + """ + from mani_skill.utils.scene_builder.robocasa.fixtures.fixture import Fixture + + if isinstance(obj, Fixture): + obj_points = obj.get_bbox_points(trans=obj_pos, rot=obj_quat) + else: + radius = obj.horizontal_radius + obj_points = obj_pos + np.array( + [ + [radius, 0, 0], + [-radius, 0, 0], + [0, radius, 0], + [0, -radius, 0], + ] + ) + + u = px - p0 + v = py - p0 + w = pz - p0 if pz is not None else None + + for point in obj_points: + check1 = np.dot(u, p0) <= np.dot(u, point) <= np.dot(u, px) + check2 = np.dot(v, p0) <= np.dot(v, point) <= np.dot(v, py) + + if not check1 or not check2: + return False + + if w is not None: + check3 = np.dot(w, p0) <= np.dot(w, point) <= np.dot(w, pz) + if not check3: + return False + + return True + + +def point_in_fixture(point, fixture, only_2d=False): + """ + check if point is inside of the exterior bounding boxes of the fixture + + Args: + point (np.array): point to check + + fixture (Fixture): fixture object + + only_2d (bool): whether to check only in 2D + """ + p0, px, py, pz = fixture.get_ext_sites(relative=False) + th = 0.00 + u = px - p0 + v = py - p0 + w = pz - p0 + check1 = np.dot(u, p0) - th <= np.dot(u, point) <= np.dot(u, px) + th + check2 = np.dot(v, p0) - th <= np.dot(v, point) <= np.dot(v, py) + th + check3 = np.dot(w, p0) - th <= np.dot(w, point) <= np.dot(w, pz) + th + + if only_2d: + return check1 and check2 + else: + return check1 and check2 and check3 + + +def objs_intersect( + obj, + obj_pos, + obj_quat, + other_obj, + other_obj_pos, + other_obj_quat, +): + """ + check if two objects intersect + """ + from mani_skill.utils.scene_builder.robocasa.fixtures.fixture import Fixture + from mani_skill.utils.scene_builder.robocasa.objects.objects import MJCFObject + + bbox_check = (isinstance(obj, MJCFObject) or isinstance(obj, Fixture)) and ( + isinstance(other_obj, MJCFObject) or isinstance(other_obj, Fixture) + ) + if bbox_check: + obj_points = obj.get_bbox_points(trans=obj_pos, rot=obj_quat) + other_obj_points = other_obj.get_bbox_points( + trans=other_obj_pos, rot=other_obj_quat + ) + + face_normals = [ + obj_points[1] - obj_points[0], + obj_points[2] - obj_points[0], + obj_points[3] - obj_points[0], + other_obj_points[1] - other_obj_points[0], + other_obj_points[2] - other_obj_points[0], + other_obj_points[3] - other_obj_points[0], + ] + + intersect = True + + # noramlize length of normals + for normal in face_normals: + normal = np.array(normal) / np.linalg.norm(normal) + + obj_projs = [np.dot(p, normal) for p in obj_points] + other_obj_projs = [np.dot(p, normal) for p in other_obj_points] + + # see if gap detected + if np.min(other_obj_projs) > np.max(obj_projs) or np.min( + obj_projs + ) > np.max(other_obj_projs): + intersect = False + break + else: + """ + old code from placement_samplers.py + """ + obj_x, obj_y, obj_z = obj_pos + other_obj_x, other_obj_y, other_obj_z = other_obj_pos + xy_collision = ( + np.linalg.norm((obj_x - other_obj_x, obj_y - other_obj_y)) + <= other_obj.horizontal_radius + obj.horizontal_radius + ) + if obj_z > other_obj_z: + z_collision = ( + obj_z - other_obj_z <= other_obj.top_offset[-1] - obj.bottom_offset[-1] + ) + else: + z_collision = ( + other_obj_z - obj_z <= obj.top_offset[-1] - other_obj.bottom_offset[-1] + ) + + if xy_collision and z_collision: + intersect = True + else: + intersect = False + + return intersect diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/placement_samplers.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/placement_samplers.py new file mode 100644 index 0000000000000000000000000000000000000000..c7c77c54030c3dd4467187daa3eee1f7753eef8c --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/placement_samplers.py @@ -0,0 +1,645 @@ +import collections +from copy import copy + +import numpy as np +from transforms3d.euler import euler2quat +from transforms3d.quaternions import qmult + +from mani_skill.utils.scene_builder.robocasa.fixtures.mujoco_object import MujocoObject +from mani_skill.utils.scene_builder.robocasa.utils.object_utils import ( + obj_in_region, + objs_intersect, +) + + +# from robocasa.utils.object_utils import obj_in_region, objs_intersect +def rotate_2d_point(input, rot): + """ + rotate a 2d vector counterclockwise + + Args: + input (np.array): 1d-array representing 2d vector + rot (float): rotation value + + Returns: + np.array: rotated 1d-array + """ + input_x, input_y = input + x = input_x * np.cos(rot) - input_y * np.sin(rot) + y = input_x * np.sin(rot) + input_y * np.cos(rot) + + return np.array([x, y]) + + +class RandomizationError(Exception): + pass + + +class ObjectPositionSampler: + """ + Base class of object placement sampler. + + Args: + name (str): Name of this sampler. + + mujoco_objects (None or MujocoObject or list of MujocoObject): single model or list of MJCF object models + + ensure_object_boundary_in_range (bool): If True, will ensure that the object is enclosed within a given boundary + (should be implemented by subclass) + + ensure_valid_placement (bool): If True, will check for correct (valid) object placements + + reference_pos (3-array): global (x,y,z) position relative to which sampling will occur + + z_offset (float): Add a small z-offset to placements. This is useful for fixed objects + that do not move (i.e. no free joint) to place them above the table. + """ + + def __init__( + self, + name, + mujoco_objects=None, + ensure_object_boundary_in_range=True, + ensure_valid_placement=True, + reference_pos=(0, 0, 0), + reference_rot=0, + z_offset=0.0, + rng=None, + ): + if rng is None: + rng = np.random.default_rng() + self.rng = rng + + # Setup attributes + self.name = name + if mujoco_objects is None: + self.mujoco_objects = [] + else: + # Shallow copy the list so we don't modify the inputted list but still keep the object references + self.mujoco_objects = ( + [mujoco_objects] + if isinstance(mujoco_objects, MujocoObject) + else copy(mujoco_objects) + ) + self.ensure_object_boundary_in_range = ensure_object_boundary_in_range + self.ensure_valid_placement = ensure_valid_placement + self.reference_pos = reference_pos + self.reference_rot = reference_rot + self.z_offset = z_offset + + def add_objects(self, mujoco_objects): + """ + Add additional objects to this sampler. Checks to make sure there's no identical objects already stored. + + Args: + mujoco_objects (MujocoObject or list of MujocoObject): single model or list of MJCF object models + """ + mujoco_objects = ( + [mujoco_objects] + if isinstance(mujoco_objects, MujocoObject) + else mujoco_objects + ) + for obj in mujoco_objects: + assert ( + obj not in self.mujoco_objects + ), "Object '{}' already in sampler!".format(obj.name) + self.mujoco_objects.append(obj) + + def reset(self): + """ + Resets this sampler. Removes all mujoco objects from this sampler. + """ + self.mujoco_objects = [] + + def sample(self, fixtures=None, reference=None, on_top=True): + """ + Uniformly sample on a surface (not necessarily table surface). + + Args: + fixtures (dict): dictionary of current object placements in the scene as well as any other relevant + obstacles that should not be in contact with newly sampled objects. Used to make sure newly + generated placements are valid. Should be object names mapped to (pos, quat, MujocoObject) + + reference (str or 3-tuple or None): if provided, sample relative placement. Can either be a string, which + corresponds to an existing object found in @fixtures, or a direct (x,y,z) value. If None, will sample + relative to this sampler's `'reference_pos'` value. + + on_top (bool): if True, sample placement on top of the reference object. + + Return: + dict: dictionary of all object placements, mapping object_names to (pos, quat, obj), including the + placements specified in @fixtures. Note quat is in (w,x,y,z) form + """ + raise NotImplementedError + + @property + def sides_combinations(self): + return { + "left": ["front_left", "back_left"], + "right": ["front_right", "back_right"], + "front": ["front_left", "front_right"], + "back": ["back_left", "back_right"], + "all": ["front_left", "front_right", "back_left", "back_right"], + } + + @property + def valid_sides(self): + return set( + [ + "left", + "right", + "front", + "back", + "all", + "front_left", + "front_right", + "back_left", + "back_right", + ] + ) + + +class UniformRandomSampler(ObjectPositionSampler): + """ + Places all objects within the table uniformly random. + + Args: + name (str): Name of this sampler. + + mujoco_objects (None or MujocoObject or list of MujocoObject): single model or list of MJCF object models + + x_range (2-array of float): Specify the (min, max) relative x_range used to uniformly place objects + + y_range (2-array of float): Specify the (min, max) relative y_range used to uniformly place objects + + rotation (None or float or Iterable): + :`None`: Add uniform random random rotation + :`Iterable (a,b)`: Uniformly randomize rotation angle between a and b (in radians) + :`value`: Add fixed angle rotation + + rotation_axis (str): Can be 'x', 'y', or 'z'. Axis about which to apply the requested rotation + + ensure_object_boundary_in_range (bool): + :`True`: The center of object is at position: + [uniform(min x_range + radius, max x_range - radius)], [uniform(min x_range + radius, max x_range - radius)] + :`False`: + [uniform(min x_range, max x_range)], [uniform(min x_range, max x_range)] + + ensure_valid_placement (bool): If True, will check for correct (valid) object placements + + reference_pos (3-array): global (x,y,z) position relative to which sampling will occur + + z_offset (float): Add a small z-offset to placements. This is useful for fixed objects + that do not move (i.e. no free joint) to place them above the table. + """ + + def __init__( + self, + name, + mujoco_objects=None, + x_range=(0, 0), + y_range=(0, 0), + rotation=None, + rotation_axis="z", + ensure_object_boundary_in_range=True, + ensure_valid_placement=True, + reference_pos=(0, 0, 0), + reference_rot=0, + z_offset=0.0, + rng=None, + side="all", + ): + self.x_range = x_range + self.y_range = y_range + self.rotation = rotation + self.rotation_axis = rotation_axis + + if side not in self.valid_sides: + raise ValueError( + "Invalid value for side, must be one of:", self.valid_sides + ) + + super().__init__( + name=name, + mujoco_objects=mujoco_objects, + ensure_object_boundary_in_range=ensure_object_boundary_in_range, + ensure_valid_placement=ensure_valid_placement, + reference_pos=reference_pos, + reference_rot=reference_rot, + z_offset=z_offset, + rng=rng, + ) + + def _sample_x(self): + """ + Samples the x location for a given object + + Returns: + float: sampled x position + """ + minimum, maximum = self.x_range + return self.rng.uniform(high=maximum, low=minimum) + + def _sample_y(self): + """ + Samples the y location for a given object + + Returns: + float: sampled y position + """ + minimum, maximum = self.y_range + return self.rng.uniform(high=maximum, low=minimum) + + def _sample_quat(self): + """ + Samples the orientation for a given object + + Returns: + np.array: sampled object quaternion in (w,x,y,z) form + + Raises: + ValueError: [Invalid rotation axis] + """ + if self.rotation is None: + rot_angle = self.rng.uniform(high=2 * np.pi, low=0) + elif isinstance(self.rotation, collections.abc.Iterable): + if isinstance(self.rotation[0], collections.abc.Iterable): + rotation = self.rng.choice(self.rotation) + else: + rotation = self.rotation + rot_angle = self.rng.uniform(high=max(rotation), low=min(rotation)) + else: + rot_angle = self.rotation + + # Return angle based on axis requested + if self.rotation_axis == "x": + return np.array([np.cos(rot_angle / 2), np.sin(rot_angle / 2), 0, 0]) + elif self.rotation_axis == "y": + return np.array([np.cos(rot_angle / 2), 0, np.sin(rot_angle / 2), 0]) + elif self.rotation_axis == "z": + return np.array([np.cos(rot_angle / 2), 0, 0, np.sin(rot_angle / 2)]) + else: + # Invalid axis specified, raise error + raise ValueError( + "Invalid rotation axis specified. Must be 'x', 'y', or 'z'. Got: {}".format( + self.rotation_axis + ) + ) + + def sample(self, placed_objects=None, reference=None, on_top=True): + """ + Uniformly sample relative to this sampler's reference_pos or @reference (if specified). + + Args: + placed_objects (dict): dictionary of current object placements in the scene as well as any other relevant + obstacles that should not be in contact with newly sampled objects. Used to make sure newly + generated placements are valid. Should be object names mapped to (pos, quat, MujocoObject) + + reference (str or 3-tuple or None): if provided, sample relative placement. Can either be a string, which + corresponds to an existing object found in @fixtures, or a direct (x,y,z) value. If None, will sample + relative to this sampler's `'reference_pos'` value. + + on_top (bool): if True, sample placement on top of the reference object. This corresponds to a sampled + z-offset of the current sampled object's bottom_offset + the reference object's top_offset + (if specified) + + Return: + dict: dictionary of all object placements, mapping object_names to (pos, quat, obj), including the + placements specified in @fixtures. Note quat is in (w,x,y,z) form + + Raises: + RandomizationError: [Cannot place all objects] + AssertionError: [Reference object name does not exist, invalid inputs] + """ + # Standardize inputs + placed_objects = {} if placed_objects is None else copy(placed_objects) + + if reference is None: + base_offset = self.reference_pos + elif type(reference) is str: + assert ( + reference in placed_objects + ), "Invalid reference received. Current options are: {}, requested: {}".format( + placed_objects.keys(), reference + ) + ref_pos, _, ref_obj = placed_objects[reference] + base_offset = np.array(ref_pos) + if on_top: + base_offset += np.array((0, 0, ref_obj.top_offset[-1])) + else: + base_offset = np.array(reference) + assert ( + base_offset.shape[0] == 3 + ), "Invalid reference received. Should be (x,y,z) 3-tuple, but got: {}".format( + base_offset + ) + + # Sample pos and quat for all objects assigned to this sampler + for obj in self.mujoco_objects: + # First make sure the currently sampled object hasn't already been sampled + assert ( + obj.name not in placed_objects + ), "Object '{}' has already been sampled!".format(obj.name) + + success = False + + # get reference rotation + euler2quat(0, 0, self.reference_rot) + # ref_quat = convert_quat( + # mat2quat(euler2mat([0, 0, self.reference_rot])), to="wxyz" + # ) + ref_quat = euler2quat(0, 0, self.reference_rot) + + ### get boundary points ### + region_points = np.array( + [ + [self.x_range[0], self.y_range[0], 0], + [self.x_range[1], self.y_range[0], 0], + [self.x_range[0], self.y_range[1], 0], + ] + ) + for i in range(len(region_points)): + region_points[i][0:2] = rotate_2d_point( + region_points[i][0:2], rot=self.reference_rot + ) + region_points += base_offset + for i in range(5000): # 5000 retries + # sample object coordinates + relative_x = self._sample_x() + relative_y = self._sample_y() + + # apply rotation + object_x, object_y = rotate_2d_point( + [relative_x, relative_y], rot=self.reference_rot + ) + + object_x = object_x + base_offset[0] + object_y = object_y + base_offset[1] + object_z = self.z_offset + base_offset[2] + if on_top: + object_z -= obj.bottom_offset[-1] + + # random rotation + quat = self._sample_quat() + quat = qmult(ref_quat, quat) + + # note (stao): what is init_quat? we might not need it + # if hasattr(obj, "init_quat"): + # quat = quat_multiply(obj.init_quat, quat) + # quat = convert_quat( + # quat_multiply( + # convert_quat(ref_quat, to="xyzw"), + # convert_quat(quat, to="xyzw"), + # ), + # to="wxyz", + # ) + + location_valid = True + + # ensure object placed fully in region + if self.ensure_object_boundary_in_range and not obj_in_region( + obj, + obj_pos=[object_x, object_y, object_z], + obj_quat=quat, + p0=region_points[0], + px=region_points[1], + py=region_points[2], + ): + location_valid = False + continue + + # TODO (stao): ensure no overlap + # objects cannot overlap + if self.ensure_valid_placement: + for (x, y, z), other_quat, other_obj in placed_objects.values(): + if objs_intersect( + obj=obj, + obj_pos=[object_x, object_y, object_z], + obj_quat=quat, + other_obj=other_obj, + other_obj_pos=[x, y, z], + other_obj_quat=other_quat, + ): + location_valid = False + break + + if location_valid: + # location is valid, put the object down + pos = (object_x, object_y, object_z) + placed_objects[obj.name] = (pos, quat, obj) + success = True + break + + if not success: + raise RandomizationError("Cannot place all objects ):") + + return placed_objects + + +class SequentialCompositeSampler(ObjectPositionSampler): + """ + Samples position for each object sequentially. Allows chaining + multiple placement initializers together - so that object locations can + be sampled on top of other objects or relative to other object placements. + + Args: + name (str): Name of this sampler. + """ + + def __init__(self, name, rng=None): + # Samplers / args will be filled in later + self.samplers = collections.OrderedDict() + self.sample_args = collections.OrderedDict() + + super().__init__(name=name, rng=rng) + + def append_sampler(self, sampler, sample_args=None): + """ + Adds a new placement initializer with corresponding @sampler and arguments + + Args: + sampler (ObjectPositionSampler): sampler to add + sample_args (None or dict): If specified, should be additional arguments to pass to @sampler's sample() + call. Should map corresponding sampler's arguments to values (excluding @fixtures argument) + + Raises: + AssertionError: [Object name in samplers] + """ + # Verify that all added mujoco objects haven't already been added, and add to this sampler's objects dict + for obj in sampler.mujoco_objects: + assert ( + obj not in self.mujoco_objects + ), f"Object '{obj.name}' already has sampler associated with it!" + self.mujoco_objects.append(obj) + self.samplers[sampler.name] = sampler + self.sample_args[sampler.name] = sample_args + + def hide(self, mujoco_objects): + """ + Helper method to remove an object from the workspace. + + Args: + mujoco_objects (MujocoObject or list of MujocoObject): Object(s) to hide + """ + sampler = UniformRandomSampler( + name="HideSampler", + mujoco_objects=mujoco_objects, + x_range=[-10, -20], + y_range=[-10, -20], + rotation=[0, 0], + rotation_axis="z", + z_offset=10, + ensure_object_boundary_in_range=False, + ensure_valid_placement=False, + rng=self.rng, + ) + self.append_sampler(sampler=sampler) + + def add_objects(self, mujoco_objects): + """ + Override super method to make sure user doesn't call this (all objects should implicitly belong to sub-samplers) + """ + raise AttributeError( + "add_objects() should not be called for SequentialCompsiteSamplers!" + ) + + def add_objects_to_sampler(self, sampler_name, mujoco_objects): + """ + Adds specified @mujoco_objects to sub-sampler with specified @sampler_name. + + Args: + sampler_name (str): Existing sub-sampler name + mujoco_objects (MujocoObject or list of MujocoObject): Object(s) to add + """ + # First verify that all mujoco objects haven't already been added, and add to this sampler's objects dict + mujoco_objects = ( + [mujoco_objects] + if isinstance(mujoco_objects, MujocoObject) + else mujoco_objects + ) + for obj in mujoco_objects: + assert ( + obj not in self.mujoco_objects + ), f"Object '{obj.name}' already has sampler associated with it!" + self.mujoco_objects.append(obj) + # Make sure sampler_name exists + assert sampler_name in self.samplers.keys(), ( + "Invalid sub-sampler specified, valid options are: {}, " + "requested: {}".format(self.samplers.keys(), sampler_name) + ) + # Add the mujoco objects to the requested sub-sampler + self.samplers[sampler_name].add_objects(mujoco_objects) + + def reset(self): + """ + Resets this sampler. In addition to base method, iterates over all sub-samplers and resets them + """ + super().reset() + for sampler in self.samplers.values(): + sampler.reset() + + def sample(self, placed_objects=None, reference=None, on_top=True): + """ + Sample from each placement initializer sequentially, in the order + that they were appended. + + Args: + placed_objects (dict): dictionary of current object placements in the scene as well as any other relevant + obstacles that should not be in contact with newly sampled objects. Used to make sure newly + generated placements are valid. Should be object names mapped to (pos, quat, MujocoObject) + + reference (str or 3-tuple or None): if provided, sample relative placement. This will override each + sampler's @reference argument if not already specified. Can either be a string, which + corresponds to an existing object found in @fixtures, or a direct (x,y,z) value. If None, will sample + relative to this sampler's `'reference_pos'` value. + + on_top (bool): if True, sample placement on top of the reference object. This will override each + sampler's @on_top argument if not already specified. This corresponds to a sampled + z-offset of the current sampled object's bottom_offset + the reference object's top_offset + (if specified) + + Return: + dict: dictionary of all object placements, mapping object_names to (pos, quat, obj), including the + placements specified in @fixtures. Note quat is in (w,x,y,z) form + + Raises: + RandomizationError: [Cannot place all objects] + """ + # Standardize inputs + placed_objects = {} if placed_objects is None else copy(placed_objects) + + # Iterate through all samplers to sample + for sampler, s_args in zip(self.samplers.values(), self.sample_args.values()): + # Pre-process sampler args + if s_args is None: + s_args = {} + for arg_name, arg in zip(("reference", "on_top"), (reference, on_top)): + if arg_name not in s_args: + s_args[arg_name] = arg + # Run sampler + new_placements = sampler.sample(placed_objects=placed_objects, **s_args) + # Update placements + placed_objects.update(new_placements) + + # only return placements for newly placed objects + sampled_obj_names = [ + obj.name + for sampler in self.samplers.values() + for obj in sampler.mujoco_objects + ] + return {k: v for (k, v) in placed_objects.items() if k in sampled_obj_names} + + +class MultiRegionSampler(ObjectPositionSampler): + def __init__( + self, + name, + regions, + side="all", + mujoco_objects=None, + rotation=None, + rotation_axis="z", + ensure_object_boundary_in_range=True, + ensure_valid_placement=True, + rng=None, + z_offset=0.0, + ): + if len(regions) != 4: + raise ValueError( + "Exactly four sites (one for each quadrant) must be provided." + ) + if side not in self.valid_sides: + raise ValueError( + "Invalid value for side, must be one of:", self.valid_sides + ) + + # initialize sides and regions + if side in self.sides_combinations: + self.sides = self.sides_combinations[side] + else: + self.sides = [side] + self.regions = regions + + # create a list of uniform samplers (one for each site) + self.samplers = list() + for s in self.sides: + site = self.regions[s] + sampler = UniformRandomSampler( + name=name, + mujoco_objects=mujoco_objects, + reference_pos=site["pos"], + x_range=site["x_range"], + y_range=site["y_range"], + rotation=rotation, + rotation_axis=rotation_axis, + ensure_object_boundary_in_range=ensure_object_boundary_in_range, + ensure_valid_placement=ensure_valid_placement, + z_offset=z_offset, + rng=rng, + ) + self.samplers.append(sampler) + + def sample(self, fixtures=None, reference=None, on_top=True): + # randomly picks a sampler and calls its sample function + sampler = self.rng.choice(self.samplers) + return sampler.sample(fixtures=fixtures, reference=reference, on_top=on_top) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/scene_registry.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/scene_registry.py new file mode 100644 index 0000000000000000000000000000000000000000..9e99f09b811c792ae79c8c58079287bfee3ee20a --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/scene_registry.py @@ -0,0 +1,153 @@ +"""Code ported over from RoboCasa: https://github.com/robocasa/robocasa/blob/main/robocasa/models/scenes/scene_registry.py""" + +from collections import OrderedDict +from enum import IntEnum + +from mani_skill import ASSET_DIR +from mani_skill.utils.scene_builder.robocasa.utils.scene_utils import ROBOCASA_ASSET_DIR + + +class LayoutType(IntEnum): + """ + Enum for available layouts in RoboCasa environment + """ + + ONE_WALL_SMALL = 0 + ONE_WALL_LARGE = 1 + L_SHAPED_SMALL = 2 + L_SHAPED_LARGE = 3 + GALLEY = 4 + U_SHAPED_SMALL = 5 + U_SHAPED_LARGE = 6 + G_SHAPED_SMALL = 7 + G_SHAPED_LARGE = 8 + WRAPAROUND = 9 + + # negative values correspond to groups (see LAYOUT_GROUPS_TO_IDS) + ALL = -1 + NO_ISLAND = -2 + ISLAND = -3 + DINING = -4 + + +LAYOUT_GROUPS_TO_IDS = { + -1: list(range(10)), # all + -2: [0, 2, 4, 5, 7], # no island + -3: [1, 3, 6, 8, 9], # island + -4: [1, 3, 6, 7, 8, 9], # dining +} + + +class StyleType(IntEnum): + """ + Enums for available styles in RoboCasa environment + """ + + INDUSTRIAL = 0 + SCANDANAVIAN = 1 + COASTAL = 2 + MODERN_1 = 3 + MODERN_2 = 4 + TRADITIONAL_1 = 5 + TRADITIONAL_2 = 6 + FARMHOUSE = 7 + RUSTIC = 8 + MEDITERRANEAN = 9 + TRANSITIONAL_1 = 10 + TRANSITIONAL_2 = 11 + + # negative values correspond to groups + ALL = -1 + + +STYLE_GROUPS_TO_IDS = { + -1: list(range(12)), # all +} + + +def get_layout_path(layout_id): + """ + Get corresponding blueprint filepath (yaml) for a layout + + Args: + layout_id (int or LayoutType): layout id (int or enum) + + Return: + str: yaml path for specified layout + """ + if isinstance(layout_id, int): + layout_int_to_name = dict( + map(lambda item: (item.value, item.name.lower()), LayoutType) + ) + layout_name = layout_int_to_name[layout_id] + elif isinstance(layout_id, LayoutType): + layout_name = layout_id.name.lower() + else: + raise ValueError + + # special case: if name starts with one letter, capitalize it + if layout_name[1] == "_": + layout_name = layout_name.capitalize() + + return str(ROBOCASA_ASSET_DIR / f"scenes/kitchen_layouts/{layout_name}.yaml") + + +def get_style_path(style_id): + """ + Get corresponding blueprint filepath (yaml) for a style + + Args: + style_id (int or StyleType): style id (int or enum) + + Return: + str: yaml path for specified style + """ + if isinstance(style_id, int): + style_int_to_name = dict( + map(lambda item: (item.value, item.name.lower()), StyleType) + ) + style_name = style_int_to_name[style_id] + elif isinstance(style_id, StyleType): + style_name = style_id.name.lower() + else: + raise ValueError + return ( + ASSET_DIR + / f"scene_datasets/robocasa_dataset/assets/scenes/kitchen_styles/{style_name}.yaml" + ) + + +def unpack_layout_ids(layout_ids): + if layout_ids is None: + layout_ids = LayoutType.ALL + + if not isinstance(layout_ids, list): + layout_ids = [layout_ids] + + layout_ids = [int(id) for id in layout_ids] + + all_layout_ids = [] + for id in layout_ids: + if id < 0: + all_layout_ids += LAYOUT_GROUPS_TO_IDS[id] + else: + all_layout_ids.append(id) + return list(OrderedDict.fromkeys(all_layout_ids)) + + +def unpack_style_ids(style_ids): + if style_ids is None: + style_ids = StyleType.ALL + + if not isinstance(style_ids, list): + style_ids = [style_ids] + + style_ids = [int(id) for id in style_ids] + + all_style_ids = [] + for id in style_ids: + if id < 0: + all_style_ids += STYLE_GROUPS_TO_IDS[id] + else: + all_style_ids.append(id) + return list(OrderedDict.fromkeys(all_style_ids)) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/scene_utils.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/scene_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b0b72d9e1bc77c26a3e05a9caa93934a5ae2703d --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/robocasa/utils/scene_utils.py @@ -0,0 +1,179 @@ +# second keyword corresponds to positive end of axis +from copy import deepcopy + +import sapien +import yaml + +from mani_skill import ASSET_DIR +from mani_skill.envs.scene import ManiSkillScene + +ROBOCASA_ASSET_DIR = ASSET_DIR / "scene_datasets/robocasa_dataset/assets" + +AXES_KEYWORDS = {0: ["left", "right"], 1: ["front", "back"], 2: ["bottom", "top"]} + +# arguments not to be passed into fixture classes when initializing +IGNORE_ARGS = [ + "name", + "align_to", + "side", + "alignment", + "type", + "center", + "offset", + "group_origin", + "group_pos", + "group_z_rot", + "stack_height", + "stack_fixtures", +] + +# arguments used to point to other fixtures +ATTACH_ARGS = ["interior_obj", "stack_on", "attach_to"] + + +def initialize_fixture(scene: ManiSkillScene, config, cur_fixtures, rng=None): + """ + initializes a fixture object based on the given configuration + ignores positional arguments as it is changed later + + Args: + config (dict): dictionary containing the fixture configuration. + Serves as the arguments to initialize the fixture + + cur_fixtures (dict): dictionary containing the current fixtures + """ + + config = deepcopy(config) + name, class_type = config["name"], config["type"] + + # set size if stack_height is specified: + if config.get("stack_height", None) is not None: + stack_height = config["stack_height"] + stack_fixtures = config["stack_fixtures"] + curr_height = 0 + for fxtr in stack_fixtures: + curr_height += cur_fixtures[fxtr].size[2] + config["size"][2] = stack_height - curr_height + + # these fields should not be passed in when initializing the fixture + for field in IGNORE_ARGS: + if field in config: + del config[field] + + if "pos" not in config: + # need position to initialize fixture, adjusted later fo relative positioning + config["pos"] = [0.0, 0.0, 0.0] + # update fixture pointers + for k in ATTACH_ARGS: + if k in config: + config[k] = cur_fixtures[config[k]] + + config["rng"] = rng + fixture = class_type(scene=scene, name=name, **config) + return fixture + + +def load_style_config(style, fixture_config): + """ + Loads the style information for a given fixture. Style information can consist of + which xml to use if there are multiple instances of a fixture, which texture to apply, + which subcomponents to apply (panels/handles for a cab), etc. + + Args: + style (dict): dictionary containing the style information for each fixture type + + fixture_config (dict): dictionary containing the fixture configuration + """ + # accounts for the different types of cabinets + fixture_type = fixture_config["type"] + + # cabinets, shelves, drawers, and boxes use the same default configurations + if "cabinet" in fixture_type or "drawer" in fixture_type or "box" in fixture_type: + fixture_type = "cabinet" + + # if fixture_type not in style: + # raise ValueError("Did not specify fixture type \"{}\" in chosen style".format(fixture_type)) + fixture_style = style.get(fixture_type, "default") + + yaml_path = str( + ASSET_DIR + / f"scene_datasets/robocasa_dataset/assets/fixtures/fixture_registry/{fixture_type}.yaml" + ) + with open(yaml_path, "r") as f: + default_configs = yaml.safe_load(f) + + # find which configuration to use + if type(fixture_style) == dict and "config_name" not in fixture_config: + if "default_config_name" in fixture_config: + config_ids = fixture_style.get( + fixture_config["default_config_name"], fixture_style["default"] + ) + del fixture_config["default_config_name"] + else: + config_ids = fixture_style["default"] + elif "default_config_name" in fixture_config: + raise ValueError('Specified "default_config_name" but no default config found') + + elif "config_name" in fixture_config: + config_ids = fixture_config["config_name"] + del fixture_config["config_name"] + else: + config_ids = fixture_style + + # search for config by name + config = default_configs["default"] + if not isinstance(config_ids, list): + config_ids = [config_ids] + for cfg_id in config_ids: + if cfg_id in default_configs: + # add additional arguments based on default config + additional_config = default_configs[cfg_id] + for k, v in additional_config.items(): + config[k] = v + else: + raise ValueError( + 'Did not find style that matches "{}" for ' + 'fixture type "{}"'.format(cfg_id, fixture_type) + ) + return config + + +def get_relative_position(fixture, config, prev_fxtr, prev_fxtr_config): + """ + Calculates the position of `fixture` based on a specified side + and alignment relative to `prev_fixture` + + This assumes that the fixtures are properly centered! + """ + + side = config["side"].lower() + alignment = config["alignment"].lower() if "alignment" in config else "center" + size = fixture.size + prev_pos, prev_size = deepcopy(prev_fxtr.pos), deepcopy(prev_fxtr.size) + # for fixtures that are not perfectly centered (e.g. stoves) + prev_pos += prev_fxtr.origin_offset + + # place fixtures next to each others + for axis, keywords in AXES_KEYWORDS.items(): + if side not in keywords: + continue + pos = deepcopy(prev_pos) + if side == keywords[1]: + pos[axis] = prev_pos[axis] + prev_size[axis] / 2 + size[axis] / 2 + elif side == keywords[0]: + pos[axis] = prev_pos[axis] - prev_size[axis] / 2 - size[axis] / 2 + + # align such that the specified faces are flush + # alignment - side compatibility is checked in check_syntax() + for axis, keywords in AXES_KEYWORDS.items(): + if keywords[0] in alignment: + pos[axis] = prev_pos[axis] - prev_size[axis] / 2 + size[axis] / 2 + elif keywords[1] in alignment: + pos[axis] = prev_pos[axis] + prev_size[axis] / 2 - size[axis] / 2 + + if "offset" in config: + pos += config["offset"] + + # for fixtures that are not perfectly centered (e.g. stoves) + pos -= fixture.origin_offset + return pos diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/scene_builder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/scene_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..46b6a7d49fb9c1741ad455e236637f64bbbdbed9 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/scene_builder.py @@ -0,0 +1,90 @@ +from __future__ import annotations + +from functools import cached_property +from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union + +import sapien +import torch +from gymnasium import spaces + +from mani_skill.utils.structs.pose import Pose + +if TYPE_CHECKING: + from mani_skill.envs.sapien_env import BaseEnv + +from mani_skill.utils.structs import Actor, Articulation +from mani_skill.utils.structs.types import Array + + +class SceneBuilder: + """Base class for defining scene builders that can be reused across tasks""" + + env: BaseEnv + """Env which scenebuilder will build in.""" + + robot_init_qpos_noise: float = 0.02 + """Robot init qpos noise""" + robot_initial_pose: Union[sapien.Pose, Pose] = sapien.Pose() + """Initial pose of the robot (passed to load_agent)""" + + builds_lighting: bool = False + """Whether this scene builder will add its own lighting when build is called. If False, ManiSkill will add some default lighting""" + + build_configs: Optional[List[Any]] = None + """List of scene configuration information that can be used to **build** scenes during reconfiguration (i.e. `env.reset(seed=seed, options=dict(reconfigure=True))`). Can be a dictionary, a path to a json file, or some other data. If a scene needs to load build config data, it will index/sample such build configs from this list.""" + init_configs: Optional[List[Any]] = None + """List of scene configuration information that can be used to **init** scenes during reconfiguration (i.e. `env.reset()`). Can be a dictionary, a path to a json file, or some other data. If a scene needs to load init config data, it will index/sample such init configs from this list.""" + + scene_objects: Optional[Dict[str, Actor]] = None + """Scene objects are any dynamic, kinematic, or static Actor built by the scene builder. Useful for accessing objects in the scene directly.""" + movable_objects: Optional[Dict[str, Actor]] = None + """Movable objects are any **dynamic** Actor built by the scene builder. movable_objects is a subset of scene_objects. Can be used to query dynamic objects for e.g. task initialization.""" + articulations: Optional[Dict[str, Articulation]] = None + """Articulations are any articulation loaded in by the scene builder.""" + + navigable_positions: Optional[List[Union[Array, spaces.Box]]] = None + """Some scenes allow for mobile robots to move through these scene. In this case, a list of navigable positions per env_idx (e.g. loaded from a navmesh) should be provided for easy initialization. Can be a discretized list, range, spaces.Box, etc.""" + + def __init__(self, env, robot_init_qpos_noise=0.02): + self.env = env + self.robot_init_qpos_noise = robot_init_qpos_noise + + def build(self, build_config_idxs: List[int] = None): + """ + Should create actor/articulation builders and only build objects into the scene without initializing pose, qpos, velocities etc. + """ + raise NotImplementedError() + + def initialize(self, env_idx: torch.Tensor, init_config_idxs: List[int] = None): + """ + Should initialize the scene, which can include e.g. setting the pose of all objects, changing the qpos/pose of articulations/robots etc. + """ + raise NotImplementedError() + + def sample_build_config_idxs(self) -> List[int]: + """ + Sample idxs of build configs for easy scene randomization. Should be changed to fit shape of self.build_configs. + """ + return torch.randint( + low=0, high=len(self.build_configs), size=(self.env.num_envs,) + ).tolist() + + def sample_init_config_idxs(self) -> List[int]: + """ + Sample idxs of init configs for easy scene randomization. Should be changed to fit shape of self.init_configs. + """ + return torch.randint( + low=0, high=len(self.init_configs), size=(self.env.num_envs,) + ).tolist() + + @cached_property + def build_config_names_to_idxs(self) -> Dict[str, int]: + return dict((v, i) for i, v in enumerate(self.build_configs)) + + @cached_property + def init_config_names_to_idxs(self) -> Dict[str, int]: + return dict((v, i) for i, v in enumerate(self.init_configs)) + + @property + def scene(self): + return self.env.scene diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..83b597a25f8b42c23b752a2d3739a3ed5f236b7f --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/__init__.py @@ -0,0 +1 @@ +from .scene_builder import TableSceneBuilder diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4dc62fe14a7875ffb0d5c2496209160d5f87e1dc Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/__pycache__/scene_builder.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/__pycache__/scene_builder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5374c88451461752846b466779e67cf3732d7d20 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/__pycache__/scene_builder.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/scene_builder.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/scene_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..eea655f629c8b581d9d566c22bae0978bb008326 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/table/scene_builder.py @@ -0,0 +1,344 @@ +import os.path as osp +from pathlib import Path +from typing import List + +import numpy as np +import sapien +import sapien.render +import torch +from transforms3d.euler import euler2quat + +from mani_skill.agents.multi_agent import MultiAgent +from mani_skill.agents.robots.fetch import FETCH_WHEELS_COLLISION_BIT +from mani_skill.utils.building.ground import build_ground +from mani_skill.utils.scene_builder import SceneBuilder + + +# TODO (stao): make the build and initialize api consistent with other scenes +class TableSceneBuilder(SceneBuilder): + def __init__(self, env, robot_init_qpos_noise=0.02, keyframe="rest"): + self.keyframe = keyframe + super().__init__(env, robot_init_qpos_noise) + + def build(self): + builder = self.scene.create_actor_builder() + model_dir = Path(osp.dirname(__file__)) / "assets" + table_model_file = str(model_dir / "table.glb") + scale = 1.75 + table_pose = sapien.Pose(q=euler2quat(0, 0, np.pi / 2)) + # builder.add_nonconvex_collision_from_file( + # filename=table_model_file, + # scale=[scale] * 3, + # pose=table_pose, + # ) + builder.add_box_collision( + pose=sapien.Pose(p=[0, 0, 0.9196429 / 2]), + half_size=(2.418 / 2, 1.209 / 2, 0.9196429 / 2), + ) + builder.add_visual_from_file( + filename=table_model_file, scale=[scale] * 3, pose=table_pose + ) + builder.initial_pose = sapien.Pose( + p=[-0.12 + 0.615, 0, -0.9196429], q=euler2quat(0, 0, np.pi / 2) + ) + table = builder.build_kinematic(name="table-workspace") + aabb = ( + table._objs[0] + .find_component_by_type(sapien.render.RenderBodyComponent) + .compute_global_aabb_tight() + ) + self.table_length = aabb[1, 0] - aabb[0, 0] + self.table_width = aabb[1, 1] - aabb[0, 1] + self.table_height = aabb[1, 2] - aabb[0, 2] + floor_width = 100 + if self.scene.parallel_in_single_scene: + floor_width = 500 + self.ground = build_ground( + self.scene, floor_width=floor_width, altitude=-self.table_height + ) + self.table = table + self.scene_objects: List[sapien.Entity] = [self.table, self.ground] + + def initialize(self, env_idx: torch.Tensor): + # table_height = 0.9196429 + b = len(env_idx) + self.table.set_pose( + sapien.Pose(p=[-0.12 + 0.615, 0, -0.9196429], q=euler2quat(0, 0, np.pi / 2)) + ) + if self.env.robot_uids == "panda": + qpos = np.array( + [ + 0.0, + np.pi / 8, + 0, + -np.pi * 5 / 8, + 0, + np.pi * 3 / 4, + np.pi / 4, + 0.04, + 0.04, + ] + ) + if self.env._enhanced_determinism: + qpos = ( + self.env._batched_episode_rng[env_idx].normal( + 0, self.robot_init_qpos_noise, len(qpos) + ) + + qpos + ) + else: + qpos = ( + self.env._episode_rng.normal( + 0, self.robot_init_qpos_noise, (b, len(qpos)) + ) + + qpos + ) + qpos[:, -2:] = 0.04 + self.env.agent.reset(qpos) + # self.env.agent.robot.set_pose(sapien.Pose([-0.615, 0, 0])) + elif self.env.robot_uids == "panda_wristcam": + # fmt: off + qpos = np.array( + [0.0, np.pi / 8, 0, -np.pi * 5 / 8, 0, np.pi * 3 / 4, np.pi / 4, 0.04, 0.04] + ) + # fmt: on + if self.env._enhanced_determinism: + qpos = ( + self.env._batched_episode_rng[env_idx].normal( + 0, self.robot_init_qpos_noise, len(qpos) + ) + + qpos + ) + else: + qpos = ( + self.env._episode_rng.normal( + 0, self.robot_init_qpos_noise, (b, len(qpos)) + ) + + qpos + ) + qpos[:, -2:] = 0.04 + self.env.agent.reset(qpos) + # self.env.agent.robot.set_pose(sapien.Pose([-0.615, 0, 0])) + elif self.env.robot_uids == "xmate3_robotiq": + qpos = np.array( + [0, np.pi / 6, 0, np.pi / 3, 0, np.pi / 2, -np.pi / 2, 0, 0] + ) + if self.env._enhanced_determinism: + qpos = ( + self.env._batched_episode_rng[env_idx].normal( + 0, self.robot_init_qpos_noise, len(qpos) + ) + + qpos + ) + else: + qpos = ( + self.env._episode_rng.normal( + 0, self.robot_init_qpos_noise, (b, len(qpos)) + ) + + qpos + ) + qpos[:, -2:] = 0 + self.env.agent.reset(qpos) + self.env.agent.robot.set_pose(sapien.Pose([-0.562, 0, 0])) + elif self.env.robot_uids in [ + "xarm6_allegro_left", + "xarm6_allegro_right", + "xarm6_robotiq", + "xarm6_nogripper", + ]: + qpos = self.env.agent.keyframes["rest"].qpos + qpos = ( + self.env._episode_rng.normal( + 0, self.robot_init_qpos_noise, (b, len(qpos)) + ) + + qpos + ) + self.env.agent.reset(qpos) + self.env.agent.robot.set_pose(sapien.Pose([-0.45, 0, 0])) + elif self.env.robot_uids == "fetch": + qpos = np.array( + [ + 0, + 0, + 0, + 0.386, + 0, + 0, + 0, + -np.pi / 4, + 0, + np.pi / 4, + 0, + np.pi / 3, + 0, + 0.015, + 0.015, + ] + ) + self.env.agent.reset(qpos) + self.env.agent.robot.set_pose(sapien.Pose([-1.05, 0, -self.table_height])) + + self.ground.set_collision_group_bit( + group=2, bit_idx=FETCH_WHEELS_COLLISION_BIT, bit=1 + ) + elif self.env.robot_uids == ("panda", "panda"): + agent: MultiAgent = self.env.agent + qpos = np.array( + [ + 0.0, + np.pi / 8, + 0, + -np.pi * 5 / 8, + 0, + np.pi * 3 / 4, + np.pi / 4, + 0.04, + 0.04, + ] + ) + if self.env._enhanced_determinism: + qpos = ( + self.env._batched_episode_rng[env_idx].normal( + 0, self.robot_init_qpos_noise, len(qpos) + ) + + qpos + ) + else: + qpos = ( + self.env._episode_rng.normal( + 0, self.robot_init_qpos_noise, (b, len(qpos)) + ) + + qpos + ) + qpos[:, -2:] = 0.04 + agent.agents[1].reset(qpos) + agent.agents[1].robot.set_pose( + sapien.Pose([0, 0.75, 0], q=euler2quat(0, 0, -np.pi / 2)) + ) + agent.agents[0].reset(qpos) + agent.agents[0].robot.set_pose( + sapien.Pose([0, -0.75, 0], q=euler2quat(0, 0, np.pi / 2)) + ) + elif self.env.robot_uids == ("panda_wristcam", "panda_wristcam"): + agent: MultiAgent = self.env.agent + qpos = np.array( + [ + 0.0, + np.pi / 8, + 0, + -np.pi * 5 / 8, + 0, + np.pi * 3 / 4, + np.pi / 4, + 0.04, + 0.04, + ] + ) + if self.env._enhanced_determinism: + qpos = ( + self.env._batched_episode_rng[env_idx].normal( + 0, self.robot_init_qpos_noise, len(qpos) + ) + + qpos + ) + else: + qpos = ( + self.env._episode_rng.normal( + 0, self.robot_init_qpos_noise, (b, len(qpos)) + ) + + qpos + ) + qpos[:, -2:] = 0.04 + agent.agents[1].reset(qpos) + agent.agents[1].robot.set_pose( + sapien.Pose([0, 0.75, 0], q=euler2quat(0, 0, -np.pi / 2)) + ) + agent.agents[0].reset(qpos) + agent.agents[0].robot.set_pose( + sapien.Pose([0, -0.75, 0], q=euler2quat(0, 0, np.pi / 2)) + ) + elif ( + "dclaw" in self.env.robot_uids + or "allegro" in self.env.robot_uids + or "trifinger" in self.env.robot_uids + ): + # Need to specify the robot qpos for each sub-scenes using tensor api + pass + elif self.env.robot_uids == "panda_stick": + qpos = np.array( + [ + 0.0, + np.pi / 8, + 0, + -np.pi * 5 / 8, + 0, + np.pi * 3 / 4, + np.pi / 4, + ] + ) + if self.env._enhanced_determinism: + qpos = ( + self.env._batched_episode_rng[env_idx].normal( + 0, self.robot_init_qpos_noise, len(qpos) + ) + + qpos + ) + else: + qpos = ( + self.env._episode_rng.normal( + 0, self.robot_init_qpos_noise, (b, len(qpos)) + ) + + qpos + ) + self.env.agent.reset(qpos) + self.env.agent.robot.set_pose(sapien.Pose([-0.615, 0, 0])) + elif self.env.robot_uids == "piper": + qpos = np.array( + [ + 0, + np.pi/2, + -np.pi/2, + 0, + 0, + 0, + 0, + 0, + ] + ) + if self.env._enhanced_determinism: + qpos = ( + self.env._batched_episode_rng[env_idx].normal( + 0, self.robot_init_qpos_noise, len(qpos) + ) + + qpos + ) + else: + qpos = ( + self.env._episode_rng.normal( + 0, self.robot_init_qpos_noise, (b, len(qpos)) + ) + + qpos + ) + self.env.agent.reset(qpos) + #self.env.agent.robot.set_pose(sapien.Pose([-0.035, 0, 0])) + + elif self.env.robot_uids in ["noahbiarm", "noahbiarm_r", "noahbiarm_rc", "noahbiarm_rcw"]: + # select the keyframe based on env_id + qpos = self.env.agent.keyframes[self.keyframe].qpos + if self.env._enhanced_determinism: + qpos = ( + self.env._batched_episode_rng[env_idx].normal( + 0, self.robot_init_qpos_noise, len(qpos) + ) + + qpos + ) + else: + qpos = ( + self.env._episode_rng.normal( + 0, self.robot_init_qpos_noise, (b, len(qpos)) + ) + + qpos + ) + qpos[:, -2:] = 0.00 + self.env.agent.reset(qpos) + self.env.agent.robot.set_pose(sapien.Pose(p=[-1, 0, -0.7])) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/structs/actor.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/structs/actor.py new file mode 100644 index 0000000000000000000000000000000000000000..4066c5b877a2bcacfaab22ed93a2d662b594c125 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/structs/actor.py @@ -0,0 +1,395 @@ +from __future__ import annotations + +from dataclasses import dataclass +from functools import cached_property +from typing import TYPE_CHECKING, List, Literal, Union + +import numpy as np +import sapien +import sapien.physx as physx +import sapien.render +import torch +import trimesh + +from mani_skill.utils import common +from mani_skill.utils.geometry.trimesh_utils import get_component_meshes, merge_meshes +from mani_skill.utils.structs.base import PhysxRigidDynamicComponentStruct +from mani_skill.utils.structs.pose import Pose, to_sapien_pose, vectorize_pose +from mani_skill.utils.structs.types import Array + +if TYPE_CHECKING: + from mani_skill.envs.scene import ManiSkillScene + + +@dataclass +class Actor(PhysxRigidDynamicComponentStruct[sapien.Entity]): + """ + Wrapper around sapien.Entity objects mixed in with useful properties from the RigidBodyDynamicComponent components + + At the moment, on GPU and CPU one can query pose, linear velocity, and angular velocity easily + + On CPU, more properties are available + """ + + px_body_type: Literal["kinematic", "static", "dynamic"] = None + hidden: bool = False + + initial_pose: Pose = None + """ + The initial pose of this Actor, as defined when creating the actor via the ActorBuilder. It is necessary to track + this pose to ensure the actor is still at the correct pose once gpu system is initialized. It may also be useful + to help reset a environment to an initial state without having to manage initial poses yourself + """ + name: str = None + + merged: bool = False + """Whether this object is a view of other actors as a result of Actor.merge""" + + def __str__(self): + return f"<{self.name}: struct of type {self.__class__}; managing {self._num_objs} {self._objs[0].__class__} objects>" + + def __repr__(self): + return self.__str__() + + def __hash__(self): + return self.__maniskill_hash__ + + @classmethod + def create_from_entities( + cls, + entities: List[sapien.Entity], + scene: ManiSkillScene, + scene_idxs: torch.Tensor, + shared_name: str = None, + ): + + if shared_name is None: + shared_name = "_".join(entities[0].name.split("_")[1:]) + bodies = [ + ent.find_component_by_type(physx.PhysxRigidDynamicComponent) + for ent in entities + ] + + # Objects with collision shapes have either PhysxRigidDynamicComponent (Kinematic, Dynamic) or PhysxRigidStaticComponent (Static) + px_body_type = "static" + if bodies[0] is not None: + if bodies[0].kinematic: + px_body_type = "kinematic" + else: + px_body_type = "dynamic" + else: + bodies = [ + ent.find_component_by_type(physx.PhysxRigidStaticComponent) + for ent in entities + ] + return cls( + _objs=entities, + scene=scene, + _scene_idxs=scene_idxs, + px_body_type=px_body_type, + _bodies=bodies, + _body_data_name=( + "cuda_rigid_body_data" + if isinstance(scene.px, physx.PhysxGpuSystem) + else None + ), + name=shared_name, + ) + + @classmethod + def merge(cls, actors: List["Actor"], name: str = None): + """ + Merge actors together under one view so that they can all be managed by one python dataclass object. + This can be useful for e.g. randomizing the asset loaded into a task and being able to do object.pose to fetch the pose of all randomized assets + or object.set_pose to change the pose of each of the different assets, despite the assets not being uniform across all sub-scenes. + + For example usage of this method, see mani_skill/envs/tasks/pick_single_ycb.py + + Args: + actors (List[Actor]): The actors to merge into one actor object to manage + name (str): A new name to give the merged actors. If none, the name will default to the first actor's name + """ + objs = [] + scene = actors[0].scene + _builder_initial_poses = [] + merged_scene_idxs = [] + for actor in actors: + objs += actor._objs + merged_scene_idxs.append(actor._scene_idxs) + _builder_initial_poses.append(actor.initial_pose.raw_pose) + merged_scene_idxs = torch.concat(merged_scene_idxs) + merged_actor = Actor.create_from_entities(objs, scene, merged_scene_idxs) + merged_actor.name = name + merged_actor.initial_pose = Pose.create(torch.vstack(_builder_initial_poses)) + merged_actor.merged = True + scene.actor_views[merged_actor.name] = merged_actor + return merged_actor + + # -------------------------------------------------------------------------- # + # Additional useful functions not in SAPIEN original API + # -------------------------------------------------------------------------- # + + def get_state(self): + pose = self.pose + if self.px_body_type != "dynamic": + vel = torch.zeros((self._num_objs, 3), device=self.device) + ang_vel = torch.zeros((self._num_objs, 3), device=self.device) + else: + vel = self.get_linear_velocity() # [N, 3] + ang_vel = self.get_angular_velocity() # [N, 3] + return torch.hstack([pose.p, pose.q, vel, ang_vel]) + + def set_state(self, state: Array, env_idx: torch.Tensor = None): + if self.scene.gpu_sim_enabled: + if env_idx is not None: + prev_reset_mask = self.scene._reset_mask.clone() + # safe guard against setting the wrong states + self.scene._reset_mask[:] = False + self.scene._reset_mask[env_idx] = True + state = common.to_tensor(state, device=self.device) + self.set_pose(Pose.create(state[:, :7])) + self.set_linear_velocity(state[:, 7:10]) + self.set_angular_velocity(state[:, 10:13]) + if env_idx is not None: + self.scene._reset_mask = prev_reset_mask + else: + state = common.to_numpy(state[0]) + self.set_pose(sapien.Pose(state[0:3], state[3:7])) + if self.px_body_type == "dynamic": + self.set_linear_velocity(state[7:10]) + self.set_angular_velocity(state[10:13]) + + @cached_property + def has_collision_shapes(self): + assert ( + not self.merged + ), "Check if a merged actor has collision shape is not supported as the managed objects could all be very different" + return ( + len( + self._objs[0] + .find_component_by_type(physx.PhysxRigidDynamicComponent) + .collision_shapes + ) + > 0 + ) + + def hide_visual(self): + """ + Hides this actor from view. In CPU simulation the visual body is simply set to visibility 0 + + For GPU simulation, currently this is implemented by moving the actor very far away as visiblity cannot be changed on the fly. + As a result we do not permit hiding and showing visuals of objects with collision shapes as this affects the actual simulation. + Note that this operation can also be fairly slow as we need to run px.gpu_apply_rigid_dynamic_data and px.gpu_fetch_rigid_dynamic_data. + """ + assert not self.has_collision_shapes + if self.hidden: + return + if self.scene.gpu_sim_enabled: + self.before_hide_pose = self.pose.raw_pose.clone() + + temp_pose = self.pose.raw_pose + temp_pose[..., :3] += 99999 + self.pose = temp_pose + self.px.gpu_apply_rigid_dynamic_data() + self.px.gpu_fetch_rigid_dynamic_data() + else: + for obj in self._objs: + obj.find_component_by_type( + sapien.render.RenderBodyComponent + ).visibility = 0 + # set hidden *after* setting/getting so not applied to self.before_hide_pose erroenously + self.hidden = True + + def show_visual(self): + assert not self.has_collision_shapes + if not self.hidden: + return + # set hidden *before* setting/getting so not applied to self.before_hide_pose erroenously + self.hidden = False + if self.scene.gpu_sim_enabled: + if hasattr(self, "before_hide_pose"): + self.pose = self.before_hide_pose + self.px.gpu_apply_rigid_dynamic_data() + self.px.gpu_fetch_rigid_dynamic_data() + else: + for obj in self._objs: + obj.find_component_by_type( + sapien.render.RenderBodyComponent + ).visibility = 1 + + def is_static(self, lin_thresh=1e-2, ang_thresh=1e-1): + """ + Checks if this actor is static within the given linear velocity threshold `lin_thresh` and angular velocity threshold `ang_thresh` + """ + return torch.logical_and( + torch.linalg.norm(self.linear_velocity, axis=1) <= lin_thresh, + torch.linalg.norm(self.angular_velocity, axis=1) <= ang_thresh, + ) + + def set_collision_group_bit(self, group: int, bit_idx: int, bit: Union[int, bool]): + """Set's a specific collision group bit for all collision shapes in all parallel actors""" + bit = int(bit) + for body in self._bodies: + for cs in body.get_collision_shapes(): + cg = cs.get_collision_groups() + cg[group] = (cg[group] & ~(1 << bit_idx)) | (bit << bit_idx) + cs.set_collision_groups(cg) + + def set_collision_group(self, group: int, value): + for body in self._bodies: + for cs in body.get_collision_shapes(): + cg = cs.get_collision_groups() + cg[group] = value + cs.set_collision_groups(cg) + + def get_first_collision_mesh(self, to_world_frame: bool = True) -> trimesh.Trimesh: + """ + Returns the collision mesh of the first managed actor object. Note results of this are not cached or optimized at the moment + so this function can be slow if called too often + + Args: + to_world_frame (bool): Whether to transform the collision mesh pose to the world frame + """ + return self.get_collision_meshes(to_world_frame=to_world_frame, first_only=True) + + def get_collision_meshes( + self, to_world_frame: bool = True, first_only: bool = False + ) -> List[trimesh.Trimesh]: + """ + Returns the collision mesh of each managed actor object. Note results of this are not cached or optimized at the moment + so this function can be slow if called too often + + Args: + to_world_frame (bool): Whether to transform the collision mesh pose to the world frame + first_only (bool): Whether to return the collision mesh of just the first actor managed by this object. If True, + this also returns a single Trimesh.Mesh object instead of a list + """ + assert ( + not self.merged + ), "Currently you cannot fetch collision meshes of merged actors" + + meshes: List[trimesh.Trimesh] = [] + + for i, actor in enumerate(self._objs): + actor_meshes = [] + for comp in actor.components: + if isinstance(comp, physx.PhysxRigidBaseComponent): + actor_meshes.append(merge_meshes(get_component_meshes(comp))) + mesh = merge_meshes(actor_meshes) + meshes.append(mesh) + if first_only: + break + if to_world_frame: + mat = self.pose + for i, mesh in enumerate(meshes): + if mat is not None: + if len(mat) > 1: + mesh.apply_transform(mat[i].sp.to_transformation_matrix()) + else: + mesh.apply_transform(mat.sp.to_transformation_matrix()) + if first_only: + return meshes[0] + return meshes + + @cached_property + def per_scene_id(self): + """ + Returns a int32 torch tensor of the actor level segmentation ID for each managed actor object. + """ + return torch.tensor( + [x.per_scene_id for x in self._objs], + device=self.device, + dtype=torch.int32, + ) + + def apply_force(self, force: Array): + """Apply an instantaneous external force to this actor in Newtons to the body's center of mass. Once called no need to call any gpu_apply_x functions as this handles it for you.""" + if self.scene.gpu_sim_enabled: + self.px.cuda_rigid_body_force.torch()[ + self._body_data_index, :3 + ] = common.to_tensor(force, device=self.device) + self.px.gpu_apply_rigid_dynamic_force() + else: + for body in self._bodies: + body.add_force_at_point( + force=force, point=(body.pose * body.cmass_local_pose).p + ) + + # -------------------------------------------------------------------------- # + # Exposed actor properties, getters/setters that automatically handle + # CPU and GPU based actors + # -------------------------------------------------------------------------- # + def remove_from_scene(self): + if self.scene.gpu_sim_enabled: + raise RuntimeError( + "Cannot physically remove object from scene during GPU simulation. This can only be done in CPU simulation. If you wish to remove an object physically, the best way is to move the object far away." + ) + else: + [obj.remove_from_scene() for obj in self._objs] + + @property + def pose(self) -> Pose: + if self.scene.gpu_sim_enabled: + if self.px_body_type == "static": + # NOTE (stao): usually _builder_initial_pose is just one pose, but for static objects in GPU sim we repeat it if necessary so it can be used + # as part of observations if needed + return self.initial_pose + else: + if self.hidden: + return Pose.create(self.before_hide_pose) + else: + raw_pose = self.px.cuda_rigid_body_data.torch()[ + self._body_data_index, :7 + ] + if self.scene.parallel_in_single_scene: + new_xyzs = ( + raw_pose[:, :3] - self.scene.scene_offsets[self._scene_idxs] + ) + new_pose = torch.zeros_like(raw_pose) + new_pose[:, 3:] = raw_pose[:, 3:] + new_pose[:, :3] = new_xyzs + raw_pose = new_pose + return Pose.create(raw_pose) + else: + return Pose.create([obj.pose for obj in self._objs]) + + @pose.setter + def pose(self, arg1: Union[Pose, sapien.Pose, Array]) -> None: + if self.scene.gpu_sim_enabled: + assert ( + self.px_body_type != "static" + ), "Static objects cannot change poses in GPU sim after environment is loaded" + if not isinstance(arg1, torch.Tensor): + arg1 = vectorize_pose(arg1, device=self.device) + if self.hidden: + self.before_hide_pose[self.scene._reset_mask[self._scene_idxs]] = arg1 + return + if self.scene.parallel_in_single_scene: + if len(arg1.shape) == 1: + arg1 = arg1.view(1, -1) + mask = self.scene._reset_mask[self._scene_idxs] + new_xyzs = ( + arg1[:, :3] + self.scene.scene_offsets[self._scene_idxs[mask]] + ) + new_pose = torch.zeros((mask.sum(), 7), device=self.device) + new_pose[:, 3:] = arg1[:, 3:] + new_pose[:, :3] = new_xyzs + arg1 = new_pose + self.px.cuda_rigid_body_data.torch()[ + self._body_data_index[self.scene._reset_mask[self._scene_idxs]], :7 + ] = arg1 + else: + if isinstance(arg1, sapien.Pose): + for obj in self._objs: + obj.pose = arg1 + else: + if isinstance(arg1, Pose) and len(arg1.shape) == 2: + for i, obj in enumerate(self._objs): + obj.pose = arg1[i].sp + else: + arg1 = to_sapien_pose(arg1) + for i, obj in enumerate(self._objs): + obj.pose = arg1 + + def set_pose(self, arg1: Union[Pose, sapien.Pose]) -> None: + self.pose = arg1 diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/structs/decorators.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/structs/decorators.py new file mode 100644 index 0000000000000000000000000000000000000000..bd34b371a39fa0706497aeab4c94b243e7851e15 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/structs/decorators.py @@ -0,0 +1,13 @@ +def before_gpu_init(func): + """ + decorator to throw an error if a function is called when gpu sim has been initialized already. Used for functions such as setting friction values which currently + cannot be changed once the gpu simulation has started. + """ + + def wrapper(self, *args, **kwargs): + assert ( + self.scene._gpu_sim_initialized == False + ), f"{func} can only be called when the GPU simulation has not been initialized yet" + return func(self, *args, **kwargs) + + return wrapper diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/structs/link.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/structs/link.py new file mode 100644 index 0000000000000000000000000000000000000000..fd2978ea1b54b568f49dfc37c6568c2bb1cb0956 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/structs/link.py @@ -0,0 +1,345 @@ +from __future__ import annotations + +from dataclasses import dataclass, field +from functools import cached_property +from typing import TYPE_CHECKING, Callable, Dict, List, Union + +import sapien +import sapien.physx as physx +import torch +import trimesh + +from mani_skill.utils.geometry.trimesh_utils import ( + get_render_shape_meshes, + merge_meshes, +) +from mani_skill.utils.structs.articulation_joint import ArticulationJoint +from mani_skill.utils.structs.base import PhysxRigidBodyComponentStruct +from mani_skill.utils.structs.pose import Pose, to_sapien_pose, vectorize_pose +from mani_skill.utils.structs.types import Array + +if TYPE_CHECKING: + from mani_skill.envs.scene import ManiSkillScene + from mani_skill.utils.structs import Articulation + + +@dataclass +class Link(PhysxRigidBodyComponentStruct[physx.PhysxArticulationLinkComponent]): + """ + Wrapper around physx.PhysxArticulationLinkComponent objects + """ + + articulation: Articulation = None + """the articulation that this link is a part of. If this is None, most likely this link object is a view/merged link object in which case + there is no one articulation that can be referenced easily""" + + name: str = None + + joint: ArticulationJoint = None + """the joint of which this link is a child of. If this is a view/merged link then this joint is also a view/merged joint""" + + meshes: Dict[str, List[trimesh.Trimesh]] = field(default_factory=dict) + """ + map from user-defined mesh groups (e.g. "handle" meshes for cabinets) to a list of trimesh.Trimesh objects corresponding to each physx link object managed here + """ + + merged: bool = False + """whether this link is result of Link.merge or not""" + + def __str__(self): + return f"<{self.name}: struct of type {self.__class__}; managing {self._num_objs} {self._objs[0].__class__} objects>" + + def __repr__(self): + return self.__str__() + + def __hash__(self): + return self.__maniskill_hash__ + + @classmethod + def create( + cls, + physx_links: List[physx.PhysxArticulationLinkComponent], + scene: ManiSkillScene, + scene_idxs: torch.Tensor, + ): + return cls( + _objs=physx_links, + scene=scene, + _scene_idxs=scene_idxs, + _body_data_name=( + "cuda_rigid_body_data" + if isinstance(scene.px, physx.PhysxGpuSystem) + else None + ), + _bodies=physx_links, + ) + + @classmethod + def merge(cls, links: List["Link"], name: str = None): + objs = [] + joint_objs = [] + merged_joint_indexes = [] + merged_active_joint_indexes = [] + articulation_objs = [] + is_root = links[0].is_root + merged_scene_idxs = [] + num_objs_per_actor = links[0]._num_objs + for link in links: + objs += link._objs + assert ( + link.is_root == is_root + ), "all links given to merge must all be root or all not be root links" + merged_scene_idxs.append(link._scene_idxs) + # if link is not root, then there are joints we can merge automatically + if not is_root: + joint_objs += link.joint._objs + articulation_objs += link.articulation._objs + + merged_active_joint_indexes.append(link.joint.active_index) + merged_joint_indexes.append(link.joint.index) + assert ( + link._num_objs == num_objs_per_actor + ), "Each given link must have the same number of managed objects" + merged_scene_idxs = torch.concat(merged_scene_idxs) + merged_link = Link.create( + objs, scene=links[0].scene, scene_idxs=merged_scene_idxs + ) + if not is_root: + merged_active_joint_indexes = torch.concat(merged_active_joint_indexes) + merged_joint_indexes = torch.concat(merged_joint_indexes) + merged_joint = ArticulationJoint.create( + joint_objs, + physx_articulations=articulation_objs, + scene=links[0].scene, + scene_idxs=merged_scene_idxs, + joint_index=merged_joint_indexes, + active_joint_index=merged_active_joint_indexes, + ) + merged_link.joint = merged_joint + merged_joint.child_link = merged_link + # remove articulation reference as it does not make sense and is only used to instantiate some properties like the physx system + # TODO (stao): akin to the joint merging above, we can also make a view of the articulations of each link. Is it necessary? + merged_link.articulation = None + merged_link.name = name + merged_link.merged = True + return merged_link + + # -------------------------------------------------------------------------- # + # Additional useful functions not in SAPIEN original API + # -------------------------------------------------------------------------- # + @property + def render_shapes(self): + """ + Returns each managed link objects render shape list (a list of lists) + """ + all_render_shapes: List[List[sapien.render.RenderShape]] = [] + for obj in self._objs: + all_render_shapes.append( + obj.entity.find_component_by_type( + sapien.render.RenderBodyComponent + ).render_shapes + ) + return all_render_shapes + + def generate_mesh( + self, + filter: Callable[ + [physx.PhysxArticulationLinkComponent, sapien.render.RenderShape], bool + ], + mesh_name: str, + ): + """ + Generates mesh objects (trimesh.Trimesh) for each managed physx link given a filter and + saves them to self.meshes[mesh_name] in addition to returning them here. + """ + # TODO (stao): should we create a Mesh wrapper? that is basically trimesh.Trimesh but all batched. + if mesh_name in self.meshes: + return self.meshes[mesh_name] + merged_meshes = [] + for link, link_render_shapes in zip(self._objs, self.render_shapes): + meshes = [] + for render_shape in link_render_shapes: + if filter(link, render_shape): + meshes.extend(get_render_shape_meshes(render_shape)) + merged_meshes.append(merge_meshes(meshes)) + self.meshes[mesh_name] = merged_meshes + return merged_meshes + + # TODO (stao): In future can we have some shared nice functions like getting center of mass of desired meshes (e.g. handle mesh?) + # def get_mesh_center_of_masses(self, mesh_name: str): + + def bbox( + self, + filter: Callable[ + [physx.PhysxArticulationLinkComponent, sapien.render.RenderShape], bool + ], + ) -> List[trimesh.primitives.Box]: + # First we need to pre-compute the bounding box of the link at 0. This will be slow the first time + bboxes = [] + for link, link_render_shapes in zip(self._objs, self.render_shapes): + meshes = [] + for render_shape in link_render_shapes: + if filter(link, render_shape): + meshes.extend(get_render_shape_meshes(render_shape)) + merged_mesh = merge_meshes(meshes) + bboxes.append(merged_mesh.bounding_box) + return bboxes + + def set_collision_group_bit(self, group: int, bit_idx: int, bit: Union[int, bool]): + """ + Set's a specific collision group bit for all collision shapes in all parallel actors + Args: + group (int): the collision group to set the bit for. Typically you only need to use group 2 to disable collision checks between links to enable faster simulation. + bit_idx (int): the bit index to set + bit (int | bool): the bit value to set. Must be 1/0 or True/False. + """ + # NOTE (stao): this collision group setting is highly specific to SAPIEN/PhysX. + bit = int(bit) + for body in self._bodies: + for cs in body.get_collision_shapes(): + cg = cs.get_collision_groups() + cg[group] = (cg[group] & ~(1 << bit_idx)) | (bit << bit_idx) + cs.set_collision_groups(cg) + + def set_collision_group(self, group: int, value): + for body in self._bodies: + for cs in body.get_collision_shapes(): + cg = cs.get_collision_groups() + cg[group] = value + cs.set_collision_groups(cg) + + def get_collision_shapes(self) -> List[PhysxCollisionShape]: + shapes = [] + for body in self._bodies: + shapes.extend(body.get_collision_shapes()) + return shapes + + @cached_property + def per_scene_id(self) -> torch.Tensor: + """ + Returns a int32 torch tensor of the link level segmentation ID for each managed link object. + """ + return torch.tensor( + [obj.entity.per_scene_id for obj in self._objs], + dtype=torch.int32, + device=self.device, + ) + + # -------------------------------------------------------------------------- # + # Functions from sapien.Component + # -------------------------------------------------------------------------- # + @property + def pose(self) -> Pose: + if self.scene.gpu_sim_enabled: + raw_pose = self.px.cuda_rigid_body_data.torch()[self._body_data_index, :7] + if self.scene.parallel_in_single_scene: + new_xyzs = raw_pose[:, :3] - self.scene.scene_offsets[self._scene_idxs] + new_pose = torch.zeros_like(raw_pose) + new_pose[:, 3:] = raw_pose[:, 3:] + new_pose[:, :3] = new_xyzs + raw_pose = new_pose + return Pose.create(raw_pose) + else: + return Pose.create([obj.entity_pose for obj in self._objs]) + + @pose.setter + def pose(self, arg1: Union[Pose, sapien.Pose, Array]) -> None: + if self.scene.gpu_sim_enabled: + if not isinstance(arg1, torch.Tensor): + arg1 = vectorize_pose(arg1, device=self.device) + if self.scene.parallel_in_single_scene: + if len(arg1.shape) == 1: + arg1 = arg1.view(1, -1) + mask = self.scene._reset_mask[self._scene_idxs] + new_xyzs = ( + arg1[:, :3] + self.scene.scene_offsets[self._scene_idxs[mask]] + ) + new_pose = torch.zeros((mask.sum(), 7), device=self.device) + new_pose[:, 3:] = arg1[:, 3:] + new_pose[:, :3] = new_xyzs + arg1 = new_pose + self.px.cuda_rigid_body_data.torch()[ + self._body_data_index[self.scene._reset_mask[self._scene_idxs]], :7 + ] = arg1 + else: + if isinstance(arg1, sapien.Pose): + for obj in self._objs: + obj.pose = arg1 + else: + if isinstance(arg1, Pose) and len(arg1.shape) == 2: + for i, obj in enumerate(self._objs): + obj.pose = arg1[i].sp + else: + arg1 = to_sapien_pose(arg1) + for i, obj in enumerate(self._objs): + obj.pose = arg1 + + def set_pose(self, arg1: Union[Pose, sapien.Pose]) -> None: + self.pose = arg1 + + # -------------------------------------------------------------------------- # + # Functions from physx.PhysxArticulationLinkComponent + # -------------------------------------------------------------------------- # + def get_articulation(self): + return self.articulation + + # def get_children(self) -> list[PhysxArticulationLinkComponent]: ... + # def get_gpu_pose_index(self) -> int: ... + def get_index(self): + return self.index + + def get_joint(self) -> ArticulationJoint: + return self.joint + + # def get_parent(self) -> PhysxArticulationLinkComponent: ... + # def put_to_sleep(self) -> None: ... + # def set_parent(self, parent: PhysxArticulationLinkComponent) -> None: ... + # def wake_up(self) -> None: ... + + # @property + # def children(self) -> list[PhysxArticulationLinkComponent]: + # """ + # :type: list[PhysxArticulationLinkComponent] + # """ + # @property + # def gpu_pose_index(self) -> int: + # """ + # :type: int + # """ + @cached_property + def index(self) -> torch.Tensor: + """The indexes of the managed link objects in their respective articulations. NOTE that these do not correspond with position in the qpos and qvel of articulations. For that index use index_q""" + return torch.tensor( + [obj.index for obj in self._objs], dtype=torch.int, device=self.device + ) + + @cached_property + def is_root(self) -> torch.Tensor: + return torch.tensor( + [obj.is_root for obj in self._objs], dtype=torch.bool, device=self.device + ) + + # @property + # def joint(self) -> physx.PhysxArticulationJoint: + # """ + # :type: PhysxArticulationJoint + # """ + # return self.joint + + # @property + # def parent(self) -> PhysxArticulationLinkComponent: + # """ + # :type: PhysxArticulationLinkComponent + # """ + # @property + # def sleeping(self) -> bool: + # """ + # :type: bool + # """ + + # @property + # def entity(self): + # return self._links[0] + + def get_name(self): + return self.name diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2cd7e9e64572799de0c62ed867c91b596cd7b337 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__init__.py @@ -0,0 +1,8 @@ +from .flatten import ( + FlattenActionSpaceWrapper, + FlattenObservationWrapper, + FlattenRGBDObservationWrapper, +) +from .frame_stack import FrameStack +from .gymnasium import CPUGymWrapper +from .record import RecordEpisode diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf2da83c063d07644cf08662f17573a4224f1a59 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/flatten.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/flatten.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ca47200c808fc96a06ade3432b428cf39be8ddaa Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/flatten.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/frame_stack.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/frame_stack.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2ec9c63c262eff3b05db2d431ae0dea34f5c172d Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/frame_stack.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/gymnasium.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/gymnasium.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42517ad522c7e6bfeeff4000ceeda29a02b4eab3 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/gymnasium.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/record.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/record.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..191a380b1b5f6b972ad5829bfd02b972f4a29623 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/__pycache__/record.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/flatten.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/flatten.py new file mode 100644 index 0000000000000000000000000000000000000000..0fcbfc0a6c44b121b8e2741ac93e0c1f2850b33b --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/flatten.py @@ -0,0 +1,119 @@ +import copy +from typing import Dict + +import gymnasium as gym +import gymnasium.spaces.utils +import numpy as np +import torch +from gymnasium.vector.utils import batch_space + +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.utils import common + + +class FlattenRGBDObservationWrapper(gym.ObservationWrapper): + """ + Flattens the rgbd mode observations into a dictionary with two keys, "rgbd" and "state" + + Args: + rgb (bool): Whether to include rgb images in the observation + depth (bool): Whether to include depth images in the observation + state (bool): Whether to include state data in the observation + + Note that the returned observations will have a "rgbd" or "rgb" or "depth" key depending on the rgb/depth bool flags. + """ + + def __init__(self, env, rgb=True, depth=True, state=True) -> None: + self.base_env: BaseEnv = env.unwrapped + super().__init__(env) + self.include_rgb = rgb + self.include_depth = depth + self.include_state = state + new_obs = self.observation(self.base_env._init_raw_obs) + self.base_env.update_obs_space(new_obs) + + def observation(self, observation: Dict): + sensor_data = observation.pop("sensor_data") + del observation["sensor_param"] + images = [] + for cam_data in sensor_data.values(): + if self.include_rgb: + images.append(cam_data["rgb"]) + if self.include_depth: + images.append(cam_data["depth"]) + + images = torch.concat(images, axis=-1) + # flatten the rest of the data which should just be state data + observation = common.flatten_state_dict( + observation, use_torch=True, device=self.base_env.device + ) + ret = dict() + if self.include_state: + ret["state"] = observation + if self.include_rgb and not self.include_depth: + ret["rgb"] = images + elif self.include_rgb and self.include_depth: + ret["rgbd"] = images + elif self.include_depth and not self.include_rgb: + ret["depth"] = images + return ret + + +class FlattenObservationWrapper(gym.ObservationWrapper): + """ + Flattens the observations into a single vector + """ + + def __init__(self, env) -> None: + super().__init__(env) + self.base_env.update_obs_space( + common.flatten_state_dict(self.base_env._init_raw_obs) + ) + + @property + def base_env(self) -> BaseEnv: + return self.env.unwrapped + + def observation(self, observation): + return common.flatten_state_dict(observation, use_torch=True) + + +class FlattenActionSpaceWrapper(gym.ActionWrapper): + """ + Flattens the action space. The original action space must be spaces.Dict + """ + + def __init__(self, env) -> None: + super().__init__(env) + self._orig_single_action_space = copy.deepcopy( + self.base_env.single_action_space + ) + self.single_action_space = gymnasium.spaces.utils.flatten_space( + self.base_env.single_action_space + ) + if self.base_env.num_envs > 1: + self.action_space = batch_space( + self.single_action_space, n=self.base_env.num_envs + ) + else: + self.action_space = self.single_action_space + + @property + def base_env(self) -> BaseEnv: + return self.env.unwrapped + + def action(self, action): + if ( + self.base_env.num_envs == 1 + and action.shape == self.single_action_space.shape + ): + action = common.batch(action) + + # TODO (stao): This code only supports flat dictionary at the moment + unflattened_action = dict() + start, end = 0, 0 + for k, space in self._orig_single_action_space.items(): + end += space.shape[0] + unflattened_action[k] = action[:, start:end] + start += space.shape[0] + return unflattened_action diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/frame_stack.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/frame_stack.py new file mode 100644 index 0000000000000000000000000000000000000000..3a3e5c4d29559ab53c4efb6083be3f773be304da --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/frame_stack.py @@ -0,0 +1,150 @@ +"""Wrapper that stacks frames. Adapted from gymnasium package to support GPU vectorizated environments.""" +from collections import deque +from typing import Union + +import gymnasium as gym +import numpy as np +import torch +from gymnasium.error import DependencyNotInstalled +from gymnasium.spaces import Box + +from mani_skill.envs.sapien_env import BaseEnv + + +class LazyFrames: + """Ensures common frames are only stored once to optimize memory use. + + To further reduce the memory use, it is optionally to turn on lz4 to compress the observations. + + Note: + This object should only be converted to numpy array just before forward pass. + """ + + __slots__ = ("frame_shape", "dtype", "shape", "lz4_compress", "_frames") + + def __init__(self, frames: list, lz4_compress: bool = False): + """Lazyframe for a set of frames and if to apply lz4. + + Args: + frames (list): The frames to convert to lazy frames + lz4_compress (bool): Use lz4 to compress the frames internally + + Raises: + DependencyNotInstalled: lz4 is not installed + """ + self.frame_shape = tuple(frames[0].shape) + self.shape = (len(frames),) + self.frame_shape + self.dtype = frames[0].dtype + self._frames = frames + self.lz4_compress = lz4_compress + + def __array__(self, dtype=None): + """Gets a torch tensor of stacked frames with specific dtype. + + Args: + dtype: The dtype of the stacked frames + + Returns: + The array of stacked frames with dtype + """ + arr = self[:] + if dtype is not None: + return arr.astype(dtype) + return arr + + def __len__(self): + """Returns the number of frame stacks. + + Returns: + The number of frame stacks + """ + return self.shape[0] + + def __getitem__(self, int_or_slice: Union[int, slice]): + """Gets the stacked frames for a particular index or slice. + + Args: + int_or_slice: Index or slice to get items for + + Returns: + torch.stacked frames for the int or slice + + """ + # if isinstance(int_or_slice, int): + # return self._check_decompress(self._frames[int_or_slice]) # single frame + return torch.stack( + [self._check_decompress(f) for f in self._frames[int_or_slice]], axis=0 + ) + + def __eq__(self, other): + """Checks that the current frames are equal to the other object.""" + return self.__array__() == other + + +class FrameStack(gym.ObservationWrapper): + """Observation wrapper that stacks the observations in a rolling manner. + + For example, if the number of stacks is 4, then the returned observation contains + the most recent 4 observations. For environment 'PickCube-v1', the original observation + is an array with shape [42], so if we stack 4 observations, the processed observation + has shape [4, 42]. + + Note: + - After :meth:`reset` is called, the frame buffer will be filled with the initial observation. + I.e. the observation returned by :meth:`reset` will consist of `num_stack` many identical frames. + """ + + def __init__( + self, + env: gym.Env, + num_stack: int, + ): + """Observation wrapper that stacks the observations in a rolling manner. + + Args: + env (Env): The environment to apply the wrapper + num_stack (int): The number of frames to stack + lz4_compress (bool): Use lz4 to compress the frames internally + """ + gym.ObservationWrapper.__init__(self, env) + + self.num_stack = num_stack + self.frames = deque(maxlen=num_stack) + [self.frames.append(self.base_env._init_raw_obs) for _ in range(self.num_stack)] + new_obs = self.observation(self.base_env._init_raw_obs) + self.base_env.update_obs_space(new_obs) + + @property + def base_env(self) -> BaseEnv: + return self.env.unwrapped + + def observation(self, observation): + return torch.stack(list(self.frames)).transpose(0, 1) + + def step(self, action): + """Steps through the environment, appending the observation to the frame buffer. + + Args: + action: The action to step through the environment with + + Returns: + Stacked observations, reward, terminated, truncated, and information from the environment + """ + observation, reward, terminated, truncated, info = self.env.step(action) + self.frames.append(observation) + return self.observation(None), reward, terminated, truncated, info + + def reset(self, **kwargs): + """Reset the environment with kwargs. + + Args: + **kwargs: The kwargs for the environment reset + + Returns: + The stacked observations + """ + obs, info = self.env.reset(**kwargs) + + [self.frames.append(obs) for _ in range(self.num_stack)] + + return self.observation(None), info diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/gymnasium.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/gymnasium.py new file mode 100644 index 0000000000000000000000000000000000000000..57b29dec39d764cfa3f330efbe74efc09de9488f --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/gymnasium.py @@ -0,0 +1,103 @@ +import gymnasium as gym +import numpy as np +import sapien.physx as physx +import torch + +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.utils import common + + +class CPUGymWrapper(gym.Wrapper): + """This wrapper wraps any maniskill env created via gym.make to ensure the outputs of + env.render, env.reset, env.step are all numpy arrays and are not batched. + Essentially ensuring the environment conforms entirely to the standard gymnasium API https://gymnasium.farama.org/api/env/. + The wrapper also optionally records standardized evaluation metrics like return and success. + + This wrapper should generally be applied after all other + wrappers as most wrappers for ManiSkill assume data returned is a batched torch tensor + + Args: + env (gym.Env): The environment to wrap. + ignore_terminations (bool): If True, the environment will ignore termination signals + and continue running until truncation. Default is False. + record_metrics (bool): If True, the returned info objects will contain the metrics: return, length, success_once, success_at_end, fail_once, fail_at_end. + success/fail metrics are recorded only when the environment has success/fail criteria. success/fail_at_end are recorded only when ignore_terminations is True. + + """ + + def __init__( + self, + env: gym.Env, + ignore_terminations: bool = False, + record_metrics: bool = False, + ): + super().__init__(env) + assert ( + self.base_env.num_envs == 1 + ), "This wrapper is only for environments without parallelization" + assert ( + not self.base_env.gpu_sim_enabled + ), "This wrapper is only for environments on the CPU backend" + self.observation_space = self.base_env.single_observation_space + self.action_space = self.base_env.single_action_space + self.ignore_terminations = ignore_terminations + self.record_metrics = record_metrics + + if self.record_metrics: + self.success_once = False + self.fail_once = False + self.returns = [] + + @property + def base_env(self) -> BaseEnv: + return self.env.unwrapped + + def step(self, action): + action = common.to_numpy(action) + obs, reward, terminated, truncated, info = self.env.step(action) + reward = common.to_numpy(reward) + info = common.to_numpy(info) + if self.record_metrics: + episode_info = dict() + self.returns.append(reward) + if "success" in info: + self.success_once = self.success_once | info["success"] + episode_info["success_once"] = self.success_once + if "fail" in info: + self.fail_once = self.fail_once | info["fail"] + episode_info["fail_once"] = self.fail_once + episode_info["return"] = np.sum(self.returns) + episode_info["episode_len"] = len(self.returns) + episode_info["reward"] = ( + episode_info["return"] / episode_info["episode_len"] + ) + if self.ignore_terminations: + terminated = False + if self.record_metrics: + if "success" in info: + episode_info["success_at_end"] = info["success"] + if "fail" in info: + episode_info["fail_at_end"] = info["fail"] + + if self.record_metrics: + info["episode"] = episode_info + return common.unbatch( + common.to_numpy(obs), + reward, + common.to_numpy(terminated), + common.to_numpy(truncated), + info, + ) + + def reset(self, *, seed=None, options=None): + obs, info = self.env.reset(seed=seed, options=options) + if self.record_metrics: + self.success_once = False + self.fail_once = False + self.returns = [] + return common.unbatch(common.to_numpy(obs), common.to_numpy(info)) + + def render(self): + ret = self.env.render() + if self.render_mode in ["rgb_array", "sensors", "all"]: + return common.unbatch(common.to_numpy(ret)) diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/record.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/record.py new file mode 100644 index 0000000000000000000000000000000000000000..d51ccec5b5f750cae9ca2050701cd05a9f47df4d --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/record.py @@ -0,0 +1,824 @@ +import copy +import time +from dataclasses import dataclass +from pathlib import Path +from typing import Callable, List, Optional, Union + +import gymnasium as gym +import h5py +import numpy as np +import sapien.physx as physx +import torch + +from mani_skill import get_commit_info +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.utils import common, gym_utils, sapien_utils +from mani_skill.utils.io_utils import dump_json +from mani_skill.utils.logging_utils import logger +from mani_skill.utils.structs.types import Array +from mani_skill.utils.visualization.misc import ( + images_to_video, + put_info_on_image, + tile_images, +) +from mani_skill.utils.wrappers import CPUGymWrapper + +# NOTE (stao): The code for record.py is quite messy and perhaps confusing as it is trying to support both recording on CPU and GPU seamlessly +# and handle partial resets. It works but can be claned up a lot. + + +def parse_env_info(env: gym.Env): + # spec can be None if not initialized from gymnasium.make + env = env.unwrapped + if env.spec is None: + return None + if hasattr(env.spec, "_kwargs"): + # gym<=0.21 + env_kwargs = env.spec._kwargs + else: + # gym>=0.22 + env_kwargs = env.spec.kwargs + return dict( + env_id=env.spec.id, + env_kwargs=env_kwargs, + ) + + +def temp_deep_print_shapes(x, prefix=""): + if isinstance(x, dict): + for k in x: + temp_deep_print_shapes(x[k], prefix=prefix + "/" + k) + else: + print(prefix, x.shape) + + +def clean_trajectories(h5_file: h5py.File, json_dict: dict, prune_empty_action=True): + """Clean trajectories by renaming and pruning trajectories in place. + + After cleanup, trajectory names are consecutive integers (traj_0, traj_1, ...), + and trajectories with empty action are pruned. + + Args: + h5_file: raw h5 file + json_dict: raw JSON dict + prune_empty_action: whether to prune trajectories with empty action + """ + json_episodes = json_dict["episodes"] + assert len(h5_file) == len(json_episodes) + + # Assumes each trajectory is named "traj_{i}" + prefix_length = len("traj_") + ep_ids = sorted([int(x[prefix_length:]) for x in h5_file.keys()]) + + new_json_episodes = [] + new_ep_id = 0 + + for i, ep_id in enumerate(ep_ids): + traj_id = f"traj_{ep_id}" + ep = json_episodes[i] + assert ep["episode_id"] == ep_id + new_traj_id = f"traj_{new_ep_id}" + + if prune_empty_action and ep["elapsed_steps"] == 0: + del h5_file[traj_id] + continue + + if new_traj_id != traj_id: + ep["episode_id"] = new_ep_id + h5_file[new_traj_id] = h5_file[traj_id] + del h5_file[traj_id] + + new_json_episodes.append(ep) + new_ep_id += 1 + + json_dict["episodes"] = new_json_episodes + + +@dataclass +class Step: + state: np.ndarray + observation: np.ndarray + action: np.ndarray + reward: np.ndarray + terminated: np.ndarray + truncated: np.ndarray + done: np.ndarray + env_episode_ptr: np.ndarray + """points to index in above data arrays where current episode started (any data before should already be flushed)""" + + success: np.ndarray = None + fail: np.ndarray = None + + +class RecordEpisode(gym.Wrapper): + """Record trajectories or videos for episodes. You generally should always apply this wrapper last, particularly if you include + observation wrappers which modify the returned observations. The only wrappers that may go after this one is any of the vector env + interface wrappers that map the maniskill env to a e.g. gym vector env interface. + + Trajectory data is saved with two files, the actual data in a .h5 file via H5py and metadata in a JSON file of the same basename. + + Each JSON file contains: + + - `env_info` (Dict): task (also known as environment) information, which can be used to initialize the task + - `env_id` (str): task id + - `max_episode_steps` (int) + - `env_kwargs` (Dict): keyword arguments to initialize the task. **Essential to recreate the environment.** + - `episodes` (List[Dict]): episode information + - `source_type` (Optional[str]): a simple category string describing what process generated the trajectory data. ManiSkill official datasets will usually write one of "human", "motionplanning", or "rl" at the moment. + - `source_desc` (Optional[str]): a longer explanation of how the data was generated. + + The episode information (the element of `episodes`) includes: + + - `episode_id` (int): a unique id to index the episode + - `reset_kwargs` (Dict): keyword arguments to reset the task. **Essential to reproduce the trajectory.** + - `control_mode` (str): control mode used for the episode. + - `elapsed_steps` (int): trajectory length + - `info` (Dict): information at the end of the episode. + + With just the meta data, you can reproduce the task the same way it was created when the trajectories were collected as so: + + ```python + env = gym.make(env_info["env_id"], **env_info["env_kwargs"]) + episode = env_info["episodes"][0] # picks the first + env.reset(**episode["reset_kwargs"]) + ``` + + Each HDF5 demonstration dataset consists of multiple trajectories. The key of each trajectory is `traj_{episode_id}`, e.g., `traj_0`. + + Each trajectory is an `h5py.Group`, which contains: + + - actions: [T, A], `np.float32`. `T` is the number of transitions. + - terminated: [T], `np.bool_`. It indicates whether the task is terminated or not at each time step. + - truncated: [T], `np.bool_`. It indicates whether the task is truncated or not at each time step. + - env_states: [T+1, D], `np.float32`. Environment states. It can be used to set the environment to a certain state via `env.set_state_dict`. However, it may not be enough to reproduce the trajectory. + - success (optional): [T], `np.bool_`. It indicates whether the task is successful at each time step. Included if task defines success. + - fail (optional): [T], `np.bool_`. It indicates whether the task is in a failure state at each time step. Included if task defines failure. + - obs (optional): [T+1, D] observations. + + Note that env_states is in a dictionary form (and observations may be as well depending on obs_mode), where it is formatted as a dictionary of lists. For example, a typical environment state looks like this: + + ```python + env_state = env.get_state_dict() + \"\"\" + env_state = { + "actors": { + "actor_id": [...numpy_actor_state...], + ... + }, + "articulations": { + "articulation_id": [...numpy_articulation_state...], + ... + } + } + \"\"\" + ``` + In the trajectory file env_states will be the same structure but each value/leaf in the dictionary will be a sequence of states representing the state of that particular entity in the simulation over time. + + In practice it is may be more useful to use slices of the env_states data (or the observations data), which can be done with + + ```python + import mani_skill.trajectory.utils as trajectory_utils + env_states = trajectory_utils.dict_to_list_of_dicts(env_states) + # now env_states[i] is the same as the data env.get_state_dict() returned at timestep i + i = 10 + env_state_i = trajectory_utils.index_dict(env_states, i) + # now env_state_i is the same as the data env.get_state_dict() returned at timestep i + ``` + + Args: + env: the environment to record + output_dir: output directory + save_trajectory: whether to save trajectory + trajectory_name: name of trajectory file (.h5). Use timestamp if not provided. + save_video: whether to save video + info_on_video: whether to write data about reward, action, and data in the info object to the video. The first video frame is generally the result + of the first env.reset() (visualizing the first observation). Text is written on frames after that, showing the action taken to get to that + environment state and reward. + save_on_reset: whether to save the previous trajectory (and video of it if `save_video` is True) automatically when resetting. + Not that for environments simulated on the GPU (to leverage fast parallel rendering) you must + set `max_steps_per_video` to a fixed number so that every `max_steps_per_video` steps a video is saved. This is + required as there may be partial environment resets which makes it ambiguous about how to save/cut videos. + save_video_trigger: a function that takes the current number of elapsed environment steps and outputs a bool. If output is True, will start saving that timestep to the video. + max_steps_per_video: how many steps can be recorded into a single video before flushing the video. If None this is not used. A internal step counter is maintained to do this. + If the video is flushed at any point, the step counter is reset to 0. + clean_on_close: whether to rename and prune trajectories when closed. + See `clean_trajectories` for details. + record_reward: whether to record the reward in the trajectory data + record_env_state: whether to record the environment state in the trajectory data + video_fps (int): The FPS of the video to generate if save_video is True + render_substeps (bool): Whether to render substeps for video. This is captures an image of the environment after each physics step. This runs slower but generates more image frames + per environment step which when coupled with a higher video FPS can yield a smoother video. + avoid_overwriting_video (bool): If true, the wrapper will iterate over possible video names to avoid overwriting existing videos in the output directory. Useful for resuming training runs. + source_type (Optional[str]): a word to describe the source of the actions used to record episodes (e.g. RL, motionplanning, teleoperation) + source_desc (Optional[str]): A longer description describing how the demonstrations are collected + """ + + def __init__( + self, + env: BaseEnv, + output_dir: str, + save_trajectory: bool = True, + trajectory_name: Optional[str] = None, + save_video: bool = True, + info_on_video: bool = False, + save_on_reset: bool = True, + save_video_trigger: Optional[Callable[[int], bool]] = None, + max_steps_per_video: Optional[int] = None, + clean_on_close: bool = True, + record_reward: bool = True, + record_env_state: bool = True, + video_fps: int = 30, + render_substeps: bool = False, + avoid_overwriting_video: bool = False, + source_type: Optional[str] = None, + source_desc: Optional[str] = None, + ) -> None: + super().__init__(env) + + self.output_dir = Path(output_dir) + if save_trajectory or save_video: + self.output_dir.mkdir(parents=True, exist_ok=True) + self.video_fps = video_fps + self._elapsed_record_steps = 0 + self._episode_id = -1 + self._video_id = -1 + self._video_steps = 0 + self._closed = False + + self.save_video_trigger = save_video_trigger + + self._trajectory_buffer: Step = None + + self.max_steps_per_video = max_steps_per_video + self.max_episode_steps = gym_utils.find_max_episode_steps_value(env) + + self.save_on_reset = save_on_reset + self.save_trajectory = save_trajectory + if self.base_env.num_envs > 1 and save_video: + assert ( + max_steps_per_video is not None + ), "On GPU parallelized environments, \ + there must be a given max steps per video value in order to flush videos in order \ + to avoid issues caused by partial resets. If your environment does not do partial \ + resets you may set max_steps_per_video equal to the max_episode_steps" + self.clean_on_close = clean_on_close + self.record_reward = record_reward + self.record_env_state = record_env_state + if self.save_trajectory: + if not trajectory_name: + trajectory_name = time.strftime("%Y%m%d_%H%M%S") + + self._h5_file = h5py.File(self.output_dir / f"{trajectory_name}.h5", "w") + + # Use a separate json to store non-array data + self._json_path = self._h5_file.filename.replace(".h5", ".json") + self._json_data = dict( + env_info=parse_env_info(self.env), + commit_info=get_commit_info(), + episodes=[], + ) + if self._json_data["env_info"] is not None: + self._json_data["env_info"][ + "max_episode_steps" + ] = self.max_episode_steps + if source_type is not None: + self._json_data["source_type"] = source_type + if source_desc is not None: + self._json_data["source_desc"] = source_desc + self._save_video = save_video + self.info_on_video = info_on_video + self.render_images = [] + self.video_nrows = int(np.sqrt(self.unwrapped.num_envs)) + self._avoid_overwriting_video = avoid_overwriting_video + + self._already_warned_about_state_dict_inconsistency = False + + # check if wrapped env is already wrapped by a CPU gym wrapper + cur_env = self.env + self.cpu_wrapped_env = False + while cur_env is not None: + if isinstance(cur_env, CPUGymWrapper): + self.cpu_wrapped_env = True + break + if hasattr(cur_env, "env"): + cur_env = cur_env.env + else: + break + + self.render_substeps = render_substeps + if self.render_substeps: + _original_after_simulation_step = self.base_env._after_simulation_step + + def wrapped_after_simulation_step(): + _original_after_simulation_step() + if self.save_video: + if self.base_env.gpu_sim_enabled: + self.base_env.scene._gpu_fetch_all() + self.render_images.append(self.capture_image()) + + self.base_env._after_simulation_step = wrapped_after_simulation_step + + @property + def num_envs(self): + return self.base_env.num_envs + + @property + def base_env(self) -> BaseEnv: + return self.env.unwrapped + + @property + def save_video(self): + if not self._save_video: + return False + if self.save_video_trigger is not None: + return self.save_video_trigger(self._elapsed_record_steps) + else: + return self._save_video + + def capture_image(self, infos=None): + img = self.env.render() + img = common.to_numpy(img) + if len(img.shape) == 3: + img = img[None] + if infos is not None: + for i in range(len(img)): + info_item = { + k: v if np.size(v) == 1 else v[i] for k, v in infos.items() + } + img[i] = put_info_on_image(img[i], info_item) + if len(img.shape) > 3: + if len(img) == 1: + img = img[0] + else: + img = tile_images(img, nrows=self.video_nrows) + return img + + def reset( + self, + *args, + seed: Optional[Union[int, List[int]]] = None, + options: Optional[dict] = dict(), + **kwargs, + ): + + if self.save_on_reset: + if self.save_video and self.num_envs == 1: + self.flush_video() + # if doing a full reset then we flush all trajectories including incompleted ones + if self._trajectory_buffer is not None: + if "env_idx" not in options: + self.flush_trajectory(env_idxs_to_flush=np.arange(self.num_envs)) + else: + self.flush_trajectory( + env_idxs_to_flush=common.to_numpy(options["env_idx"]) + ) + + obs, info = super().reset(*args, seed=seed, options=options, **kwargs) + if info["reconfigure"]: + # if we reconfigure, there is the possibility that state dictionary looks different now + # so trajectory buffer must be wiped + self._trajectory_buffer = None + if self.save_trajectory: + state_dict = self.base_env.get_state_dict() + action = common.batch( + self.env.get_wrapper_attr("single_action_space").sample() + ) + # check if state_dict is consistent + if not sapien_utils.is_state_dict_consistent(state_dict): + self.record_env_state = False + if not self._already_warned_about_state_dict_inconsistency: + logger.warn( + f"State dictionary is not consistent, disabling recording of environment states for {self.env}" + ) + self._already_warned_about_state_dict_inconsistency = True + first_step = Step( + state=None, + observation=common.to_numpy(common.batch(obs)), + # note first reward/action etc. are ignored when saving trajectories to disk + action=common.to_numpy(common.batch(action.repeat(self.num_envs, 0))), + reward=np.zeros( + ( + 1, + self.num_envs, + ), + dtype=float, + ), + # terminated and truncated are fixed to be True at the start to indicate the start of an episode. + # an episode is done when one of these is True otherwise the trajectory is incomplete / a partial episode + terminated=np.ones((1, self.num_envs), dtype=bool), + truncated=np.ones((1, self.num_envs), dtype=bool), + done=np.ones((1, self.num_envs), dtype=bool), + success=np.zeros((1, self.num_envs), dtype=bool), + fail=np.zeros((1, self.num_envs), dtype=bool), + env_episode_ptr=np.zeros((self.num_envs,), dtype=int), + ) + if self.record_env_state: + first_step.state = common.to_numpy(common.batch(state_dict)) + env_idx = np.arange(self.num_envs) + if "env_idx" in options: + env_idx = common.to_numpy(options["env_idx"]) + if self._trajectory_buffer is None: + # Initialize trajectory buffer on the first episode based on given observation (which should be generated after all wrappers) + self._trajectory_buffer = first_step + else: + + def recursive_replace(x, y): + if isinstance(x, np.ndarray): + x[-1, env_idx] = y[-1, env_idx] + else: + for k in x.keys(): + recursive_replace(x[k], y[k]) + + # TODO (stao): how do we store states from GPU sim of tasks with objects not in every sub-scene? + # Maybe we shouldn't? + if self.record_env_state: + recursive_replace(self._trajectory_buffer.state, first_step.state) + recursive_replace( + self._trajectory_buffer.observation, first_step.observation + ) + recursive_replace(self._trajectory_buffer.action, first_step.action) + if self.record_reward: + recursive_replace(self._trajectory_buffer.reward, first_step.reward) + recursive_replace( + self._trajectory_buffer.terminated, first_step.terminated + ) + recursive_replace( + self._trajectory_buffer.truncated, first_step.truncated + ) + recursive_replace(self._trajectory_buffer.done, first_step.done) + if self._trajectory_buffer.success is not None: + recursive_replace( + self._trajectory_buffer.success, first_step.success + ) + if self._trajectory_buffer.fail is not None: + recursive_replace(self._trajectory_buffer.fail, first_step.fail) + if options is not None and "env_idx" in options: + options["env_idx"] = common.to_numpy(options["env_idx"]) + self.last_reset_kwargs = copy.deepcopy(dict(options=options, **kwargs)) + if seed is not None: + self.last_reset_kwargs.update(seed=seed) + return obs, info + + def step(self, action): + if self.save_video and self._video_steps == 0: + # save the first frame of the video here (s_0) instead of inside reset as user + # may call env.reset(...) multiple times but we want to ignore empty trajectories + self.render_images.append(self.capture_image()) + obs, rew, terminated, truncated, info = super().step(action) + + if self.save_trajectory: + state_dict = self.base_env.get_state_dict() + if self.record_env_state: + self._trajectory_buffer.state = common.append_dict_array( + self._trajectory_buffer.state, + common.to_numpy(common.batch(state_dict)), + ) + self._trajectory_buffer.observation = common.append_dict_array( + self._trajectory_buffer.observation, + common.to_numpy(common.batch(obs)), + ) + + self._trajectory_buffer.action = common.append_dict_array( + self._trajectory_buffer.action, + common.to_numpy(common.batch(action)), + ) + if self.record_reward: + self._trajectory_buffer.reward = common.append_dict_array( + self._trajectory_buffer.reward, + common.to_numpy(common.batch(rew)), + ) + self._trajectory_buffer.terminated = common.append_dict_array( + self._trajectory_buffer.terminated, + common.to_numpy(common.batch(terminated)), + ) + self._trajectory_buffer.truncated = common.append_dict_array( + self._trajectory_buffer.truncated, + common.to_numpy(common.batch(truncated)), + ) + done = terminated | truncated + self._trajectory_buffer.done = common.append_dict_array( + self._trajectory_buffer.done, + common.to_numpy(common.batch(done)), + ) + if "success" in info: + self._trajectory_buffer.success = common.append_dict_array( + self._trajectory_buffer.success, + common.to_numpy(common.batch(info["success"])), + ) + else: + self._trajectory_buffer.success = None + if "fail" in info: + self._trajectory_buffer.fail = common.append_dict_array( + self._trajectory_buffer.fail, + common.to_numpy(common.batch(info["fail"])), + ) + else: + self._trajectory_buffer.fail = None + + if self.save_video: + self._video_steps += 1 + if self.info_on_video: + scalar_info = gym_utils.extract_scalars_from_info( + common.to_numpy(info), batch_size=self.num_envs + ) + scalar_info["reward"] = common.to_numpy(rew) + if np.size(scalar_info["reward"]) > 1: + scalar_info["reward"] = [ + float(rew) for rew in scalar_info["reward"] + ] + else: + scalar_info["reward"] = float(scalar_info["reward"]) + image = self.capture_image(scalar_info) + else: + image = self.capture_image() + + self.render_images.append(image) + if ( + self.max_steps_per_video is not None + and self._video_steps >= self.max_steps_per_video + ): + self.flush_video() + self._elapsed_record_steps += 1 + return obs, rew, terminated, truncated, info + + def flush_trajectory( + self, + verbose=False, + ignore_empty_transition=True, + env_idxs_to_flush=None, + save: bool = True, + ): + """ + Flushes a trajectory and by default saves it to disk + + Arguments: + verbose (bool): whether to print out information about the flushed trajectory + ignore_empty_transition (bool): whether to ignore trajectories that did not have any actions + env_idxs_to_flush: which environments by id to flush. If None, all environments are flushed. + save (bool): whether to save the trajectory to disk + """ + flush_count = 0 + if env_idxs_to_flush is None: + env_idxs_to_flush = np.arange(0, self.num_envs) + for env_idx in env_idxs_to_flush: + start_ptr = self._trajectory_buffer.env_episode_ptr[env_idx] + end_ptr = len(self._trajectory_buffer.done) + if ignore_empty_transition and end_ptr - start_ptr <= 1: + continue + flush_count += 1 + if save: + self._episode_id += 1 + traj_id = "traj_{}".format(self._episode_id) + group = self._h5_file.create_group(traj_id, track_order=True) + + def recursive_add_to_h5py( + group: h5py.Group, data: Union[dict, Array], key + ): + """simple recursive data insertion for nested data structures into h5py, optimizing for visual data as well""" + if isinstance(data, dict): + subgrp = group.create_group(key, track_order=True) + for k in data.keys(): + recursive_add_to_h5py(subgrp, data[k], k) + else: + if key == "rgb": + # NOTE(jigu): It is more efficient to use gzip than png for a sequence of images. + group.create_dataset( + "rgb", + data=data[start_ptr:end_ptr, env_idx], + dtype=data.dtype, + compression="gzip", + compression_opts=5, + ) + elif key == "depth": + # NOTE (stao): By default now cameras in ManiSkill return depth values of type uint16 for numpy + group.create_dataset( + key, + data=data[start_ptr:end_ptr, env_idx], + dtype=data.dtype, + compression="gzip", + compression_opts=5, + ) + elif key == "seg": + group.create_dataset( + key, + data=data[start_ptr:end_ptr, env_idx], + dtype=data.dtype, + compression="gzip", + compression_opts=5, + ) + else: + group.create_dataset( + key, + data=data[start_ptr:end_ptr, env_idx], + dtype=data.dtype, + ) + + # Observations need special processing + if isinstance(self._trajectory_buffer.observation, dict): + recursive_add_to_h5py( + group, self._trajectory_buffer.observation, "obs" + ) + elif isinstance(self._trajectory_buffer.observation, np.ndarray): + if self.cpu_wrapped_env: + group.create_dataset( + "obs", + data=self._trajectory_buffer.observation[start_ptr:end_ptr], + dtype=self._trajectory_buffer.observation.dtype, + ) + else: + group.create_dataset( + "obs", + data=self._trajectory_buffer.observation[ + start_ptr:end_ptr, env_idx + ], + dtype=self._trajectory_buffer.observation.dtype, + ) + else: + raise NotImplementedError( + f"RecordEpisode wrapper does not know how to handle observation data of type {type(self._trajectory_buffer.observation)}" + ) + episode_info = dict( + episode_id=self._episode_id, + episode_seed=self.base_env._episode_seed[env_idx], + control_mode=self.base_env.control_mode, + elapsed_steps=end_ptr - start_ptr - 1, + ) + if self.num_envs == 1: + episode_info.update(reset_kwargs=self.last_reset_kwargs) + else: + # NOTE (stao): With multiple envs in GPU simulation, reset_kwargs do not make much sense + episode_info.update(reset_kwargs=dict()) + + # slice some data to remove the first dummy frame. + actions = common.index_dict_array( + self._trajectory_buffer.action, + (slice(start_ptr + 1, end_ptr), env_idx), + ) + terminated = self._trajectory_buffer.terminated[ + start_ptr + 1 : end_ptr, env_idx + ] + truncated = self._trajectory_buffer.truncated[ + start_ptr + 1 : end_ptr, env_idx + ] + if isinstance(self._trajectory_buffer.action, dict): + recursive_add_to_h5py(group, actions, "actions") + else: + group.create_dataset("actions", data=actions, dtype=np.float32) + group.create_dataset("terminated", data=terminated, dtype=bool) + group.create_dataset("truncated", data=truncated, dtype=bool) + + if self._trajectory_buffer.success is not None: + group.create_dataset( + "success", + data=self._trajectory_buffer.success[ + start_ptr + 1 : end_ptr, env_idx + ], + dtype=bool, + ) + episode_info.update( + success=self._trajectory_buffer.success[end_ptr - 1, env_idx] + ) + if self._trajectory_buffer.fail is not None: + group.create_dataset( + "fail", + data=self._trajectory_buffer.fail[ + start_ptr + 1 : end_ptr, env_idx + ], + dtype=bool, + ) + episode_info.update( + fail=self._trajectory_buffer.fail[end_ptr - 1, env_idx] + ) + if self.record_env_state: + recursive_add_to_h5py( + group, self._trajectory_buffer.state, "env_states" + ) + if self.record_reward: + group.create_dataset( + "rewards", + data=self._trajectory_buffer.reward[ + start_ptr + 1 : end_ptr, env_idx + ], + dtype=np.float32, + ) + + self._json_data["episodes"].append(common.to_numpy(episode_info)) + dump_json(self._json_path, self._json_data, indent=2) + if verbose: + if flush_count == 1: + print(f"Recorded episode {self._episode_id}") + else: + print( + f"Recorded episodes {self._episode_id - flush_count} to {self._episode_id}" + ) + + # truncate self._trajectory_buffer down to save memory + if flush_count > 0: + self._trajectory_buffer.env_episode_ptr[env_idxs_to_flush] = ( + len(self._trajectory_buffer.done) - 1 + ) + min_env_ptr = self._trajectory_buffer.env_episode_ptr.min() + N = len(self._trajectory_buffer.done) + + if self.record_env_state: + self._trajectory_buffer.state = common.index_dict_array( + self._trajectory_buffer.state, slice(min_env_ptr, N) + ) + self._trajectory_buffer.observation = common.index_dict_array( + self._trajectory_buffer.observation, slice(min_env_ptr, N) + ) + self._trajectory_buffer.action = common.index_dict_array( + self._trajectory_buffer.action, slice(min_env_ptr, N) + ) + if self.record_reward: + self._trajectory_buffer.reward = common.index_dict_array( + self._trajectory_buffer.reward, slice(min_env_ptr, N) + ) + self._trajectory_buffer.terminated = common.index_dict_array( + self._trajectory_buffer.terminated, slice(min_env_ptr, N) + ) + self._trajectory_buffer.truncated = common.index_dict_array( + self._trajectory_buffer.truncated, slice(min_env_ptr, N) + ) + self._trajectory_buffer.done = common.index_dict_array( + self._trajectory_buffer.done, slice(min_env_ptr, N) + ) + if self._trajectory_buffer.success is not None: + self._trajectory_buffer.success = common.index_dict_array( + self._trajectory_buffer.success, slice(min_env_ptr, N) + ) + if self._trajectory_buffer.fail is not None: + self._trajectory_buffer.fail = common.index_dict_array( + self._trajectory_buffer.fail, slice(min_env_ptr, N) + ) + self._trajectory_buffer.env_episode_ptr -= min_env_ptr + + def flush_video( + self, + name=None, + suffix="", + verbose=False, + ignore_empty_transition=True, + save: bool = True, + ): + """ + Flush a video of the recorded episode(s) anb by default saves it to disk + + Arguments: + name (str): name of the video file. If None, it will be named with the episode id. + suffix (str): suffix to add to the video file name + verbose (bool): whether to print out information about the flushed video + ignore_empty_transition (bool): whether to ignore trajectories that did not have any actions + save (bool): whether to save the video to disk + """ + if len(self.render_images) == 0: + return + if ignore_empty_transition and len(self.render_images) == 1: + return + if save: + self._video_id += 1 + if name is None: + video_name = "{}".format(self._video_id) + if suffix: + video_name += "_" + suffix + if self._avoid_overwriting_video: + while ( + Path(self.output_dir) + / (video_name.replace(" ", "_").replace("\n", "_") + ".mp4") + ).exists(): + self._video_id += 1 + video_name = "{}".format(self._video_id) + if suffix: + video_name += "_" + suffix + else: + video_name = name + images_to_video( + self.render_images, + str(self.output_dir), + video_name=video_name, + fps=self.video_fps, + verbose=verbose, + ) + self._video_steps = 0 + self.render_images = [] + + def close(self) -> None: + if self._closed: + # There is some strange bug when vector envs using record wrapper are closed/deleted, this code runs twice + return + self._closed = True + if self.save_trajectory: + # Handle the last episode only when `save_on_reset=True` + if self.save_on_reset and self._trajectory_buffer is not None: + self.flush_trajectory( + ignore_empty_transition=True, + env_idxs_to_flush=np.arange(self.num_envs), + ) + if self.clean_on_close: + clean_trajectories(self._h5_file, self._json_data) + dump_json(self._json_path, self._json_data, indent=2) + self._h5_file.close() + if self.save_video: + if self.save_on_reset: + self.flush_video() + return super().close() diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/visual_encoders.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/visual_encoders.py new file mode 100644 index 0000000000000000000000000000000000000000..46c6b41c0deb9de6607ec4bee5655e86e91f7740 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/wrappers/visual_encoders.py @@ -0,0 +1,59 @@ +from typing import Dict, Literal + +import gymnasium as gym +import torch + +from mani_skill.envs.sapien_env import BaseEnv +from mani_skill.utils import common + + +class VisualEncoderWrapper(gym.ObservationWrapper): + def __init__(self, env, encoder: Literal["r3m"], encoder_config=dict()): + self.base_env: BaseEnv = env.unwrapped + assert encoder == "r3m", "Only encoder='r3m' is supported at the moment" + if encoder == "r3m": + assert self.base_env.obs_mode in [ + "rgbd", + "rgb", + ], "r3m encoder requires obs_mode to be set to rgbd or rgb" + import torchvision.transforms as T + from r3m import load_r3m + + # self.num_images = len(venv.observation_space['image']) + self.model = load_r3m("resnet18") # resnet18, resnet34 + self.model.eval() + self.model.to(self.base_env.device) + self.transforms = T.Compose( + [ + T.Resize((224, 224), antialias=True), + ] + ) # HWC -> CHW + self.single_image_embedding_size = 512 # for resnet18 + + self.base_env.update_obs_space( + common.to_numpy( + self.observation(common.to_tensor(self.base_env._init_raw_obs)) + ) + ) + super().__init__(env) + + @torch.no_grad() + def observation(self, obs: Dict): + vec_img_embeddings_list = [] + image_obs = obs.pop("sensor_data") + del obs["sensor_param"] + for image in image_obs.values(): + vec_image = image["rgb"] # (N, H, W, 3), [0, 255] torch.int16 + vec_image = self.transforms( + vec_image.permute(0, 3, 1, 2) + ) # (numenv, 3, 224, 224) + vec_image = vec_image.to(self.base_env.device) + vec_img_embedding = self.model( + vec_image + ).detach() # (numenv, self.single_image_embedding_size) + vec_img_embeddings_list.append(vec_img_embedding) + vec_embedding = torch.cat( + vec_img_embeddings_list, dim=-1 + ) # (numenv, self.image_embedding_size) + obs["embedding"] = vec_embedding + return obs diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d0cfc6118966217bdaad92835e9d1868400c8b61 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/__init__.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/__pycache__/__init__.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ffdd41dd72d122b397fcdc4e4458eb3d77cb6d9 Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/__pycache__/__init__.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/__pycache__/gymnasium.cpython-310.pyc b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/__pycache__/gymnasium.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d762d822269ae105c8b936eecb78d4b4e7857d2b Binary files /dev/null and b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/__pycache__/gymnasium.cpython-310.pyc differ diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/gymnasium.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/gymnasium.py new file mode 100644 index 0000000000000000000000000000000000000000..1a378814d5f06e224f5ea4e3327d7c07f8d641ba --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/gymnasium.py @@ -0,0 +1,173 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union + +import gymnasium as gym +import torch +from gymnasium.vector import VectorEnv + +from mani_skill.utils.structs.types import Array +from mani_skill.utils.common import torch_clone_dict + +if TYPE_CHECKING: + from mani_skill.envs.sapien_env import BaseEnv + + +class ManiSkillVectorEnv(VectorEnv): + """ + Gymnasium Vector Env implementation for ManiSkill environments running on the GPU for parallel simulation and optionally parallel rendering + + Note that currently this also assumes modeling tasks as infinite horizon (e.g. terminations is always False, only reset when timelimit is reached) + + Args: + env: The environment created via gym.make / after wrappers are applied. If a string is given, we use gym.make(env) to create an environment + num_envs: The number of parallel environments. This is only used if the env argument is a string + env_kwargs: Environment kwargs to pass to gym.make. This is only used if the env argument is a string + auto_reset (bool): Whether this wrapper will auto reset the environment (following the same API/conventions as Gymnasium). + Default is True (recommended as most ML/RL libraries use auto reset) + ignore_terminations (bool): Whether this wrapper ignores terminations when deciding when to auto reset. Terminations can be caused by + the task reaching a success or fail state as defined in a task's evaluation function. Default is False, meaning there is early stop in + episode rollouts. If set to True, this would generally for situations where you may want to model a task as infinite horizon where a task + stops only due to the timelimit. + record_metrics (bool): If True, the returned info objects will contain the metrics: return, length, success_once, success_at_end, fail_once, fail_at_end. + success/fail metrics are recorded only when the environment has success/fail criteria. success/fail_at_end are recorded only when ignore_terminations is True. + """ + + def __init__( + self, + env: Union[BaseEnv, str], + num_envs: int = None, + auto_reset: bool = True, + ignore_terminations: bool = False, + record_metrics: bool = False, + **kwargs, + ): + if isinstance(env, str): + self._env = gym.make(env, num_envs=num_envs, **kwargs) + else: + self._env = env + num_envs = self.base_env.num_envs + self.auto_reset = auto_reset + self.ignore_terminations = ignore_terminations + self.record_metrics = record_metrics + self.spec = self._env.spec + super().__init__( + num_envs, + self._env.get_wrapper_attr("single_observation_space"), + self._env.get_wrapper_attr("single_action_space"), + ) + if not self.ignore_terminations and auto_reset: + assert ( + self.base_env.reconfiguration_freq == 0 or self.base_env.num_envs == 1 + ), "With partial resets, environment cannot be reconfigured automatically" + + if self.record_metrics: + self.success_once = torch.zeros( + self.num_envs, device=self.base_env.device, dtype=torch.bool + ) + self.fail_once = torch.zeros( + self.num_envs, device=self.base_env.device, dtype=torch.bool + ) + self.returns = torch.zeros( + self.num_envs, device=self.base_env.device, dtype=torch.float32 + ) + + @property + def device(self): + return self.base_env.device + + @property + def base_env(self) -> BaseEnv: + return self._env.unwrapped + + @property + def unwrapped(self): + return self.base_env + + def reset( + self, + *, + seed: Optional[Union[int, List[int]]] = None, + options: Optional[dict] = dict(), + ): + obs, info = self._env.reset(seed=seed, options=options) + if "env_idx" in options: + env_idx = options["env_idx"] + mask = torch.zeros(self.num_envs, dtype=bool, device=self.base_env.device) + mask[env_idx] = True + if self.record_metrics: + self.success_once[mask] = False + self.fail_once[mask] = False + self.returns[mask] = 0 + else: + if self.record_metrics: + self.success_once[:] = False + self.fail_once[:] = False + self.returns[:] = 0 + return obs, info + + def step( + self, actions: Union[Array, Dict] + ) -> Tuple[Array, Array, Array, Array, Dict]: + obs, rew, terminations, truncations, infos = self._env.step(actions) + + if self.record_metrics: + episode_info = dict() + self.returns += rew + if "success" in infos: + self.success_once = self.success_once | infos["success"] + episode_info["success_once"] = self.success_once.clone() + if "fail" in infos: + self.fail_once = self.fail_once | infos["fail"] + episode_info["fail_once"] = self.fail_once.clone() + episode_info["return"] = self.returns.clone() + episode_info["episode_len"] = self.base_env.elapsed_steps.clone() + episode_info["reward"] = ( + episode_info["return"] / episode_info["episode_len"] + ) + + if isinstance(terminations, bool): + terminations = torch.tensor([terminations], device=self.device) + + if self.ignore_terminations: + terminations[:] = False + if self.record_metrics: + if "success" in infos: + episode_info["success_at_end"] = infos["success"].clone() + if "fail" in infos: + episode_info["fail_at_end"] = infos["fail"].clone() + if self.record_metrics: + infos["episode"] = episode_info + + dones = torch.logical_or(terminations, truncations) + + if dones.any() and self.auto_reset: + final_obs = torch_clone_dict(obs) + env_idx = torch.arange(0, self.num_envs, device=self.device)[dones] + final_info = torch_clone_dict(infos) + obs, infos = self.reset(options=dict(env_idx=env_idx)) + # gymnasium calls it final observation but it really is just o_{t+1} or the true next observation + infos["final_observation"] = final_obs + infos["final_info"] = final_info + # NOTE (stao): that adding masks like below is a bit redundant and not necessary + # but this is to follow the standard gymnasium API + infos["_final_info"] = dones + infos["_final_observation"] = dones + infos["_elapsed_steps"] = dones + # NOTE (stao): Unlike gymnasium, the code here does not add masks for every key in the info object. + return obs, rew, terminations, truncations, infos + + def close(self): + return self._env.close() + + def call(self, name: str, *args, **kwargs): + function = getattr(self._env, name) + return function(*args, **kwargs) + + def get_attr(self, name: str): + raise RuntimeError( + "To get an attribute get it from the .env property of this object" + ) + + def render(self): + return self.base_env.render() diff --git a/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/sb3.py b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/sb3.py new file mode 100644 index 0000000000000000000000000000000000000000..8b49451d87f33d8201d9c481460e9d658cb81cf0 --- /dev/null +++ b/project/ManiSkill3/src/maniskill3_environment/mani_skill/vector/wrappers/sb3.py @@ -0,0 +1,138 @@ +import time +from typing import Any, List, Optional, Type, Union + +import gymnasium as gym +import numpy as np +import torch +from stable_baselines3.common.vec_env.base_vec_env import VecEnv as SB3VecEnv +from stable_baselines3.common.vec_env.base_vec_env import ( + VecEnvIndices, + VecEnvObs, + VecEnvStepReturn, +) + +from mani_skill.envs.sapien_env import BaseEnv + + +def select_index_from_dict(data: Union[dict, np.ndarray], i: int): + if isinstance(data, np.ndarray): + return data[i] + elif isinstance(data, dict): + out = dict() + for k, v in data.items(): + out[k] = select_index_from_dict(v, i) + return out + else: + return data[i] + + +# TODO +class ManiSkillSB3VectorEnv(SB3VecEnv): + """A wrapper for to make ManiSkill parallel simulation compatible with SB3 VecEnv and auto adds the monitor wrapper""" + + def __init__(self, env: BaseEnv): + super().__init__( + env.num_envs, env.single_observation_space, env.single_action_space + ) + self._env = env + self._last_seed = None + self.t_start = time.time() + self.episode_returns: torch.Tensor = torch.zeros( + self.num_envs, device=self.base_env.device + ) + self.episode_lengths: torch.Tensor = torch.zeros( + self.num_envs, device=self.base_env.device + ) + self.episode_times: torch.Tensor = torch.zeros( + self.num_envs, device=self.base_env.device + ) + self.total_steps = 0 + + @property + def base_env(self) -> BaseEnv: + return self._env.unwrapped + + def seed(self, seed: Optional[int] = None) -> List[Union[None, int]]: + self._last_seed = seed + + def reset(self) -> VecEnvObs: + self.episode_returns = torch.zeros(self.num_envs, device=self.base_env.device) + self.episode_lengths = torch.zeros(self.num_envs, device=self.base_env.device) + obs = self._env.reset(seed=self._last_seed)[0] + self._last_seed = None # use seed from call to seed() once + return obs.cpu().numpy() # currently SB3 only support numpy arrays + + def step_async(self, actions: np.ndarray) -> None: + self.last_actions = actions + + def step_wait(self) -> VecEnvStepReturn: + vec_obs, rews, terminations, truncations, infos = self._env.step( + self.last_actions + ) + + self.episode_returns += rews + self.episode_lengths += 1 + dones = terminations | truncations + + # Convert observations, rewards, and dones to numpy arrays + vec_obs = vec_obs.cpu().numpy() + rews = rews.cpu().numpy() + dones = dones.cpu().numpy() + new_infos = [] + + for env_idx in range(self.num_envs): + new_info = { + "TimeLimit.truncated": truncations[env_idx] + and not terminations[env_idx], + "episode": { + "r": self.episode_returns.cpu().numpy(), + "l": self.episode_lengths.cpu().numpy(), + }, + } + # , "t": round(time.time() - self.t_start, 6)} + new_infos.append(new_info) + # Store terminal observations + for i, done in enumerate(dones): + if done: + if "success" in infos: + new_infos[i]["is_success"] = infos["success"][i].cpu().numpy() + new_infos[i]["terminal_observation"] = select_index_from_dict( + vec_obs, i + ) + + # Reset environments where episodes have ended + if dones.any(): + reset_indices = np.where(dones)[0] + new_obs = self._env.reset(options=dict(env_idx=reset_indices))[0] + vec_obs[reset_indices] = new_obs[reset_indices].cpu().numpy() + self.episode_returns[reset_indices] = 0 + self.episode_lengths[reset_indices] = 0 + + return vec_obs, rews, dones, new_infos + + def close(self) -> None: + return self._env.close() + + def get_attr(self, attr_name: str, indices: VecEnvIndices = None) -> List[Any]: + return self._env.get_attr(attr_name, indices) + + def set_attr( + self, attr_name: str, value: Any, indices: VecEnvIndices = None + ) -> None: + return self._env.set_attr(attr_name, value, indices) + + def env_method( + self, + method_name: str, + *method_args, + indices: VecEnvIndices = None, + **method_kwargs + ) -> List[Any]: + return self._env.env_method( + method_name, *method_args, indices=indices, **method_kwargs + ) + + def env_is_wrapped( + self, wrapper_class: Type[gym.Wrapper], indices: VecEnvIndices = None + ) -> List[bool]: + return [False] * self.num_envs