def test_stage_attributes_managers(): cfg_settings = examples.settings.default_sim_settings.copy() cfg_settings[ "scene"] = "data/scene_datasets/habitat-test-scenes/van-gogh-room.glb" cfg_settings["enable_physics"] = True hab_cfg = examples.settings.make_cfg(cfg_settings) with habitat_sim.Simulator(hab_cfg) as sim: stage_name = cfg_settings["scene"] # get attribute managers stage_mgr = sim.get_stage_template_manager() # perform general tests for this attributes manager template0, _ = perform_general_tests(stage_mgr, stage_name) # verify gravity in template is as expected assert template0.gravity == mn.Vector3(0.0, -9.8, 0.0) # verify creating new template perform_add_blank_template_test(stage_mgr, template0.render_asset_handle)
def __init__(self, config: Config) -> None: self.config = config agent_config = self._get_agent_config() sim_sensors = [] for sensor_name in agent_config.SENSORS: sensor_cfg = getattr(self.config, sensor_name) sensor_type = registry.get_sensor(sensor_cfg.TYPE) assert sensor_type is not None, "invalid sensor type {}".format( sensor_cfg.TYPE) sim_sensors.append(sensor_type(sensor_cfg)) self._sensor_suite = SensorSuite(sim_sensors) self.sim_config = self.create_sim_config(self._sensor_suite) self._current_scene = self.sim_config.sim_cfg.scene.id self._sim = habitat_sim.Simulator(self.sim_config) self._action_space = spaces.Discrete( len(self.sim_config.agents[0].action_space)) self._is_episode_active = False
def test_no_navmesh_smoke(): sim_cfg = habitat_sim.SimulatorConfiguration() agent_config = habitat_sim.AgentConfiguration() # No sensors as we are only testing to see if things work # with no navmesh and the navmesh isn't used for any exisitng sensors agent_config.sensor_specifications = [] sim_cfg.scene.id = "data/scene_datasets/habitat-test-scenes/van-gogh-room.glb" # Make it try to load a navmesh that doesn't exists sim_cfg.scene.filepaths["navmesh"] = "/tmp/dne.navmesh" sim = habitat_sim.Simulator( habitat_sim.Configuration(sim_cfg, [agent_config])) sim.initialize_agent(0) random.seed(0) for _ in range(50): obs = sim.step(random.choice(list(agent_config.action_space.keys()))) # Can't collide with no navmesh assert not obs["collided"]
def test_empty_scene(): cfg_settings = examples.settings.default_sim_settings.copy() # keyword "NONE" initializes a scene with no scene mesh cfg_settings["scene"] = "NONE" # test that depth sensor doesn't mind an empty scene cfg_settings["depth_sensor"] = True hab_cfg = examples.settings.make_cfg(cfg_settings) hab_cfg_mm = examples.settings.make_cfg(cfg_settings) mm = habitat_sim.metadata.MetadataMediator(hab_cfg.sim_cfg) hab_cfg_mm.metadata_mediator = mm test_list = [hab_cfg, hab_cfg_mm] for ctor_arg in test_list: with habitat_sim.Simulator(ctor_arg) as sim: assert sim.get_stage_initialization_template() == None # test that empty frames can be rendered without a scene mesh for _ in range(2): sim.step(random.choice(list(hab_cfg.agents[0].action_space.keys())))
def __init__( self, scene_filepath, labels=[0.0], img_size=(512, 512), output=["rgba"], sim=None, ): self.scene_filepath = scene_filepath self.labels = set(labels) self.cfg = self._config_sim(self.scene_filepath, img_size) if sim is None: sim = habitat_sim.Simulator(self.cfg) else: # If a sim is provided we have to make a new cfg self.cfg = self._config_sim(sim.config.sim_cfg.scene.id, img_size) sim.reconfigure(self.cfg) self.sim = sim self.pixels_per_meter = 0.1 ref_point = self._get_pathfinder_reference_point(self.sim.pathfinder) self.tdv = TopdownView(self.sim, ref_point[1], self.pixels_per_meter) self.topdown_view = self.tdv.topdown_view self.pose_extractor = PoseExtractor( self.topdown_view, self.sim.pathfinder, self.pixels_per_meter ) self.poses = self.pose_extractor.extract_poses( labels=self.labels ) # list of poses self.label_map = {0.0: "unnavigable", 1.0: "navigable"} # Configure the output each data sample self.out_name_to_sensor_name = { "rgba": "color_sensor", "depth": "depth_sensor", "semantic": "semantic_sensor", } self.output = output
def __init__(self): test_scene = Config().scene sim_settings = { "width": 640, # Spatial resolution of the observations "height": 480, "scene": test_scene, # Scene path "default_agent": 0, "sensor_height": 1.5, # Height of sensors in meters "color_sensor": True, # RGB sensor "semantic_sensor": True, # Semantic sensor "depth_sensor": True, # Depth sensor "seed": 1, } cfg = self.make_cfg(sim_settings) self.sim = habitat_sim.Simulator(cfg) self.action_names = list( cfg.agents[sim_settings["default_agent"]].action_space.keys()) self.total_frames = 0
def init_sim(sim_settings, start_pos, start_rot): cfg = make_cfg(sim_settings) sim = habitat_sim.Simulator(cfg) # Actions should change the position of the agent as well. action = habitat_sim.registry.get_move_fn("move_up") action.body_action = True action = habitat_sim.registry.get_move_fn("move_down") action.body_action = True random.seed(sim_settings["seed"]) sim.seed(sim_settings["seed"]) # Set agent state agent = sim.initialize_agent(sim_settings["default_agent"]) agent_state = habitat_sim.AgentState() agent_state.position = np.array(start_pos) # Agent start position set agent_state.rotation = quaternion.quaternion( *start_rot) # Agent start orientation set agent.set_state(agent_state) return sim, agent, cfg
def test_unproject(): cfg_settings = examples.settings.default_sim_settings.copy() # configure some settings in case defaults change cfg_settings[ "scene"] = "data/scene_datasets/habitat-test-scenes/apartment_1.glb" cfg_settings["width"] = 101 cfg_settings["height"] = 101 cfg_settings["sensor_height"] = 0 cfg_settings["color_sensor"] = True # loading the scene hab_cfg = examples.settings.make_cfg(cfg_settings) with habitat_sim.Simulator(hab_cfg) as sim: # position agent sim.agents[0].scene_node.rotation = mn.Quaternion() sim.agents[0].scene_node.translation = mn.Vector3(0.5, 0, 0) # setup camera visual_sensor = sim._sensors["color_sensor"] scene_graph = sim.get_active_scene_graph() scene_graph.set_default_render_camera_parameters( visual_sensor._sensor_object) render_camera = scene_graph.get_default_render_camera() # test unproject center_ray = render_camera.unproject(mn.Vector2i( 50, 50)) # middle of the viewport assert np.allclose(center_ray.origin, np.array([0.5, 0, 0]), atol=0.07) assert np.allclose(center_ray.direction, np.array([0, 0, -1.0]), atol=0.02) test_ray_2 = render_camera.unproject(mn.Vector2i( 100, 100)) # bottom right of the viewport assert np.allclose(test_ray_2.direction, np.array([0.569653, -0.581161, -0.581161]), atol=0.07)
def test_no_navmesh_smoke(): sim_cfg = habitat_sim.SimulatorConfiguration() agent_config = habitat_sim.AgentConfiguration() # No sensors as we are only testing to see if things work # with no navmesh and the navmesh isn't used for any exisitng sensors agent_config.sensor_specifications = [] sim_cfg.scene_id = "data/test_assets/scenes/stage_floor1.glb" hab_cfg = habitat_sim.Configuration(sim_cfg, [agent_config]) mm = habitat_sim.metadata.MetadataMediator(sim_cfg) hab_cfg_mm = habitat_sim.Configuration(sim_cfg, [agent_config], mm) test_list = [hab_cfg, hab_cfg_mm] for ctor_arg in test_list: with habitat_sim.Simulator(ctor_arg) as sim: sim.initialize_agent(0) random.seed(0) for _ in range(50): obs = sim.step(random.choice(list(agent_config.action_space.keys()))) # Can't collide with no navmesh assert not obs["collided"]
def init_common(self): self._cfg = make_cfg(self._sim_settings) scene_file = self._sim_settings["scene"] if (not os.path.exists(scene_file) and scene_file == default_sim_settings["test_scene"]): print( "Test scenes not downloaded locally, downloading and extracting now..." ) utils.download_and_unzip( default_sim_settings["test_scene_data_url"], ".") print("Downloaded and extracted test scenes data.") self._sim = habitat_sim.Simulator(self._cfg) random.seed(self._sim_settings["seed"]) self._sim.seed(self._sim_settings["seed"]) # initialize the agent at a random start state start_state = self.init_agent_state( self._sim_settings["default_agent"]) return start_state
def setup_sim_and_sensors(): left_rgb_sensor = create_sensor(position=[eye_seperation / 2, 0, 0], sensor_uuid="left_rgb_sensor") right_rgb_sensor = create_sensor(position=[-eye_seperation / 2, 0, 0], sensor_uuid="right_rgb_sensor") depth_sensor = create_sensor(sensor_uuid="depth_sensor", camera_type="D") # agent configuration has the sensor_specifications objects as a list new_agent_config = habitat_sim.AgentConfiguration() new_agent_config.sensor_specifications = [left_rgb_sensor, right_rgb_sensor, depth_sensor] # Configuration of the backend of the simulator includes default_agent_id set to 0 backend_cfg = habitat_sim.SimulatorConfiguration() default_agent_id = backend_cfg.default_agent_id backend_cfg.foveation_distortion = True backend_cfg.scene.id = ( "../multi_agent/data_files/skokloster-castle.glb" ) # backend_cfg.scene.id = ( # "/Users/rajan/My_Replica/replica_v1/room_2/mesh.ply" # ) # Tie the backend of the simulator and a list of agent configurations new_Configuration = habitat_sim.Configuration(backend_cfg, [new_agent_config]) # When Simulator is called the agent configuration becomes Agents (only one agent in our case] new_sim = habitat_sim.Simulator(new_Configuration) return new_sim, default_agent_id
def test_random_seed(): # reconfigure to ensure pathfinder exists cfg_settings = examples.settings.default_sim_settings.copy() hab_cfg = examples.settings.make_cfg(cfg_settings) with habitat_sim.Simulator(hab_cfg) as sim: # Test that the same seed gives the same point sim.seed(1) point1 = sim.pathfinder.get_random_navigable_point() sim.seed(1) point2 = sim.pathfinder.get_random_navigable_point() assert all(point1 == point2) # Test that different seeds give different points sim.seed(2) point1 = sim.pathfinder.get_random_navigable_point() sim.seed(3) point2 = sim.pathfinder.get_random_navigable_point() assert any(point1 != point2) # Test that the same seed gives different points when sampled twice sim.seed(4) point1 = sim.pathfinder.get_random_navigable_point() point2 = sim.pathfinder.get_random_navigable_point() assert any(point1 != point2)
def test_sim_reset(make_cfg_settings): hab_cfg = examples.settings.make_cfg(make_cfg_settings) hab_cfg_mm = examples.settings.make_cfg(make_cfg_settings) mm = habitat_sim.metadata.MetadataMediator(hab_cfg.sim_cfg) hab_cfg_mm.metadata_mediator = mm test_list = [hab_cfg, hab_cfg_mm] for ctor_arg in test_list: with habitat_sim.Simulator(ctor_arg) as sim: agent_config = sim.config.agents[0] sim.initialize_agent(0) initial_state = sim.agents[0].initial_state # Take random steps in the environment for _ in range(10): action = random.choice(list(agent_config.action_space.keys())) sim.step(action) sim.reset() new_state = sim.agents[0].get_state() same_position = all(initial_state.position == new_state.position) same_rotation = np.isclose( initial_state.rotation, new_state.rotation, rtol=1e-4) # Numerical error can cause slight deviations assert same_position and same_rotation
def make_simulator_from_settings(sim_settings): cfg = make_cfg(sim_settings) # clean-up the current simulator instance if it exists global sim global obj_attr_mgr global prim_attr_mgr global stage_attr_mgr global rigid_obj_mgr global metadata_mediator if sim != None: sim.close() # initialize the simulator sim = habitat_sim.Simulator(cfg) # Managers of various Attributes templates obj_attr_mgr = sim.get_object_template_manager() obj_attr_mgr.load_configs( str(os.path.join(data_path, "objects/example_objects"))) prim_attr_mgr = sim.get_asset_template_manager() stage_attr_mgr = sim.get_stage_template_manager() # Manager providing access to rigid objects rigid_obj_mgr = sim.get_rigid_object_manager() # get metadata_mediator metadata_mediator = sim.metadata_mediator # UI-populated handles used in various cells. Need to initialize to valid # value in case IPyWidgets are not available. # Holds the user's desired file-based object template handle global sel_file_obj_handle sel_file_obj_handle = obj_attr_mgr.get_file_template_handles()[0] # Holds the user's desired primitive-based object template handle global sel_prim_obj_handle sel_prim_obj_handle = obj_attr_mgr.get_synth_template_handles()[0] # Holds the user's desired primitive asset template handle global sel_asset_handle sel_asset_handle = prim_attr_mgr.get_template_handles()[0]
def test_smoke_redwood_noise(scene, gpu2gpu, make_cfg_settings): if not osp.exists(scene): pytest.skip("Skipping {}".format(scene)) if not habitat_sim.cuda_enabled and gpu2gpu: pytest.skip("Skipping GPU->GPU test") make_cfg_settings["depth_sensor"] = True make_cfg_settings["color_sensor"] = False make_cfg_settings["semantic_sensor"] = False make_cfg_settings["scene"] = scene hsim_cfg = make_cfg(make_cfg_settings) hsim_cfg.agents[0].sensor_specifications[0].noise_model = "RedwoodDepthNoiseModel" for sensor_spec in hsim_cfg.agents[0].sensor_specifications: sensor_spec.gpu2gpu_transfer = gpu2gpu with habitat_sim.Simulator(hsim_cfg) as sim: obs, gt = _render_and_load_gt(sim, scene, "depth_sensor", gpu2gpu) assert np.linalg.norm( obs["depth_sensor"].astype(float) - gt.astype(float) ) > 1.5e-2 * np.linalg.norm(gt.astype(float)), "Incorrect depth_sensor output" sim.close()
def main(show_imgs=True, save_imgs=False): if save_imgs and not os.path.exists(output_path): os.mkdir(output_path) # [default scene lighting] # create the simulator and render flat shaded scene cfg = make_configuration() sim = habitat_sim.Simulator(cfg) agent_transform = place_agent(sim) get_obs(sim, show_imgs, save_imgs) # [scene swap shader] # close the simulator and re-initialize with DEFAULT_LIGHTING_KEY: sim.close() cfg = make_configuration() cfg.sim_cfg.scene_light_setup = habitat_sim.gfx.DEFAULT_LIGHTING_KEY sim = habitat_sim.Simulator(cfg) agent_transform = place_agent(sim) get_obs(sim, show_imgs, save_imgs) # create and register new light setup: my_scene_lighting_setup = [ LightInfo(vector=[0.0, 2.0, 0.6, 0.0], model=LightPositionModel.GLOBAL) ] sim.set_light_setup(my_scene_lighting_setup, "my_scene_lighting") # reconfigure with custom key: new_cfg = make_configuration() new_cfg.sim_cfg.scene_light_setup = "my_scene_lighting" sim.reconfigure(new_cfg) agent_transform = place_agent(sim) get_obs(sim, show_imgs, save_imgs) # [/scene] # reset to default scene shading sim.close() cfg = make_configuration() sim = habitat_sim.Simulator(cfg) agent_transform = place_agent(sim) # noqa: F841 # [example 2] # get the physics object attributes manager obj_templates_mgr = sim.get_object_template_manager() # load some object templates from configuration files sphere_template_id = obj_templates_mgr.load_configs( str(os.path.join(data_path, "test_assets/objects/sphere")))[0] chair_template_id = obj_templates_mgr.load_configs( str(os.path.join(data_path, "test_assets/objects/chair")))[0] id_1 = sim.add_object(sphere_template_id) sim.set_translation([3.2, 0.23, 0.03], id_1) get_obs(sim, show_imgs, save_imgs) # [/example 2] # [example 3] # create a custom light setup my_default_lighting = [ LightInfo(vector=[2.0, 2.0, 1.0, 0.0], model=LightPositionModel.CAMERA) ] # overwrite the default DEFAULT_LIGHTING_KEY light setup sim.set_light_setup(my_default_lighting) get_obs(sim, show_imgs, save_imgs) # [/example 3] # [example 4] id_2 = sim.add_object(chair_template_id) sim.set_rotation(mn.Quaternion.rotation(mn.Deg(-115), mn.Vector3.y_axis()), id_2) sim.set_translation([3.06, 0.47, 1.15], id_2) get_obs(sim, show_imgs, save_imgs) # [/example 4] # [example 5] light_setup_2 = [ LightInfo( vector=[2.0, 1.5, 5.0, 1.0], color=[0.0, 100.0, 100.0], model=LightPositionModel.GLOBAL, ) ] sim.set_light_setup(light_setup_2, "my_custom_lighting") # [/example 5] remove_all_objects(sim) # [example 6] id_1 = sim.add_object(chair_template_id, light_setup_key="my_custom_lighting") sim.set_rotation(mn.Quaternion.rotation(mn.Deg(-115), mn.Vector3.y_axis()), id_1) sim.set_translation([3.06, 0.47, 1.15], id_1) id_2 = sim.add_object(chair_template_id, light_setup_key="my_custom_lighting") sim.set_rotation(mn.Quaternion.rotation(mn.Deg(50), mn.Vector3.y_axis()), id_2) sim.set_translation([3.45927, 0.47, -0.624958], id_2) get_obs(sim, show_imgs, save_imgs) # [/example 6] # [example 7] existing_light_setup = sim.get_light_setup("my_custom_lighting") # create a new setup with an additional light new_light_setup = existing_light_setup + [ LightInfo( vector=[0.0, 0.0, 1.0, 0.0], color=[1.6, 1.6, 1.4], model=LightPositionModel.CAMERA, ) ] # register the old setup under a new name sim.set_light_setup(existing_light_setup, "my_old_custom_lighting") # [/example 7] # [example 8] # register the new setup overwriting the old one sim.set_light_setup(new_light_setup, "my_custom_lighting") get_obs(sim, show_imgs, save_imgs) # [/example 8] # [example 9] sim.set_object_light_setup(id_1, habitat_sim.gfx.DEFAULT_LIGHTING_KEY) get_obs(sim, show_imgs, save_imgs)
def main(show_imgs=True, save_imgs=False): if save_imgs: if not os.path.exists(output_path): os.mkdir(output_path) # [semantic id] # create the simulator and render flat shaded scene cfg = make_configuration(scene_file="NONE") sim = habitat_sim.Simulator(cfg) test_scenes = [ "data/scene_datasets/habitat-test-scenes/apartment_1.glb", "data/scene_datasets/habitat-test-scenes/van-gogh-room.glb", ] for scene in test_scenes: # reconfigure the simulator with a new scene asset cfg = make_configuration(scene_file=scene) sim.reconfigure(cfg) agent_transform = place_agent(sim) # noqa: F841 get_obs(sim, show_imgs, save_imgs) # get the physics object attributes manager obj_templates_mgr = sim.get_object_template_manager() # load some chair object template from configuration file chair_template_id = obj_templates_mgr.load_object_configs( str(os.path.join(data_path, "test_assets/objects/chair")))[0] # add 2 chairs with default semanticId == 0 and arrange them chair_ids = [] chair_ids.append(sim.add_object(chair_template_id)) chair_ids.append(sim.add_object(chair_template_id)) sim.set_rotation( mn.Quaternion.rotation(mn.Deg(-115), mn.Vector3.y_axis()), chair_ids[0]) sim.set_translation([2.0, 0.47, 0.9], chair_ids[0]) sim.set_translation([2.9, 0.47, 0.0], chair_ids[1]) get_obs(sim, show_imgs, save_imgs) # set the semanticId for both chairs sim.set_object_semantic_id(2, chair_ids[0]) sim.set_object_semantic_id(2, chair_ids[1]) get_obs(sim, show_imgs, save_imgs) # set the semanticId for one chair sim.set_object_semantic_id(1, chair_ids[1]) get_obs(sim, show_imgs, save_imgs) # add a box with default semanticId configured in the template box_template = habitat_sim.attributes.PhysicsObjectAttributes() box_template.render_asset_handle = str( os.path.join(data_path, "test_assets/objects/transform_box.glb")) box_template.scale = np.array([0.2, 0.2, 0.2]) # set the default semantic id for this object template box_template.semantic_id = 10 obj_templates_mgr = sim.get_object_template_manager() box_template_id = obj_templates_mgr.register_template( box_template, "box") box_id = sim.add_object(box_template_id) sim.set_translation([3.5, 0.47, 0.9], box_id) sim.set_rotation( mn.Quaternion.rotation(mn.Deg(-30), mn.Vector3.y_axis()), box_id) get_obs(sim, show_imgs, save_imgs) # set semantic id for specific SceneNode components of the box object box_visual_nodes = sim.get_object_visual_scene_nodes(box_id) box_visual_nodes[6].semantic_id = 3 box_visual_nodes[7].semantic_id = 4 get_obs(sim, show_imgs, save_imgs)
my_agent_config.sensor_specifications = [ left_rgb_sensor, right_rgb_sensor, depth_sensor ] # Configuration of the backend of the simulator includes default_agent_id set to 0 backend_cfg = habitat_sim.SimulatorConfiguration() default_agent_id = backend_cfg.default_agent_id backend_cfg.foveation_distortion = True #backend_cfg.foveation_distortion = False backend_cfg.scene.id = ( "/Users/rajan/My_Replica/replica_v1/room_2/mesh.ply") # Tie the backend of the simulator and a list of agent configurations my_Configuration = habitat_sim.Configuration(backend_cfg, [my_agent_config]) my_sim = habitat_sim.Simulator(my_Configuration) print("Initial Left sensor orientation = {}".format( left_rgb_sensor.orientation)) my_agent = my_sim.get_agent(default_agent_id) my_agent_state = my_agent.get_state() print("Agent orientation = {}".format(my_agent_state.rotation)) print("Agent-Left RGB Sensor orientation = {}".format( my_agent_state.sensor_states['left_rgb_sensor'].rotation)) my_agent_state.sensor_states[ 'right_rgb_sensor'].rotation = quaternion.from_rotation_vector( [0.0, 0.0, 0.0]) my_agent_state.sensor_states[ 'left_rgb_sensor'].rotation = quaternion.from_rotation_vector( [0.0, 0.0, 0.0]) '''
def __init__(self, scene, result_folder, depth_camera=False, loc_depth_cam='c', foveation=False): self.agent_config = habitat_sim.AgentConfiguration() # Left sensor - # oreo perspective - staring at -ive z self.left_sensor = habitat_sim.SensorSpec() self.left_sensor.sensor_type = habitat_sim.SensorType.COLOR self.left_sensor.resolution = sensor_resolution self.left_sensor.uuid = "left_rgb_sensor" self.left_sensor.position = [-eye_separation / 2, 0.0, 0.0] self.left_sensor.orientation = np.array([0.0, 0.0, 0.0], dtype=float) self.left_sensor_hfov = math.radians( int(self.left_sensor.parameters['hfov'])) self.focal_distance = sensor_resolution[0] / ( 2 * math.tan(self.left_sensor_hfov / 2)) # Right sensor - # oreo perspective - staring at -ive z self.right_sensor = habitat_sim.SensorSpec() self.right_sensor.sensor_type = habitat_sim.SensorType.COLOR self.right_sensor.resolution = sensor_resolution self.right_sensor.uuid = "right_rgb_sensor" self.right_sensor.position = [eye_separation / 2, 0.0, 0.0] self.right_sensor.orientation = np.array([0.0, 0.0, 0.0], dtype=float) self.right_sensor_hfov = math.radians( int(self.right_sensor.parameters['hfov'])) if self.right_sensor_hfov != self.left_sensor_hfov: print("Warning - Right and Left Sensor widths are not identical!") # Depth camera - At the origin of the reference coordinate axes (habitat frame) if depth_camera: self.num_sensors = 3 self.depth_sensor = habitat_sim.SensorSpec() self.depth_sensor.sensor_type = habitat_sim.SensorType.DEPTH self.depth_sensor.resolution = sensor_resolution self.depth_sensor.uuid = "depth_sensor" if loc_depth_cam == 'l': self.depth_sensor.position = self.left_sensor.position elif loc_depth_cam == 'r': self.depth_sensor.position = self.right_sensor.position else: self.depth_sensor.position = [0.0, 0.0, 0.0] self.depth_sensor.orientation = np.array([0.0, 0.0, 0.0], dtype=float) self.agent_config.sensor_specifications = [ self.right_sensor, self.left_sensor, self.depth_sensor ] else: self.num_sensors = 2 self.agent_config.sensor_specifications = [ self.right_sensor, self.left_sensor ] self.backend_cfg = habitat_sim.SimulatorConfiguration() if foveation: self.backend_cfg.foveation_distortion = True self.backend_cfg.scene.id = scene #This works in older habitat versions # self.backend_cfg.scene_id = scene #newer versions like the colab install self.destination = os.path.realpath(result_folder) if not os.path.isdir(self.destination): os.makedirs(self.destination) # Tie the backend of the simulator and the list of agent configurations (only one) self.sim_configuration = habitat_sim.Configuration( self.backend_cfg, [self.agent_config]) self.sim = habitat_sim.Simulator(self.sim_configuration) self.agent_id = self.backend_cfg.default_agent_id self.agent = self.sim.get_agent(self.agent_id) self.initial_agent_state = self.agent.get_state() print( f"Agent rotation {self.initial_agent_state.rotation} Agent position {self.initial_agent_state.position}" ) # agent_head_neck_rotation (not a part of habitat api to keep track of head/neck rotation wrt to the agent. # HabitatAI api agent rotation is not rotation of agent wrt to WCS followed by rotation of head/neck self.agent_head_neck_rotation = np.quaternion(1, 0, 0, 0) self.counter = 0 # counter for saccade file numbering self.filename = self.create_unique_filename(scene) self.my_images = self.get_sensor_observations() self.current_saved_image = "empty" return
def test_dynamics(): # This test assumes that default.phys_scene_config.json contains "physics simulator": "bullet". # TODO: enable dynamic override of this setting in simulation config structure cfg_settings = examples.settings.default_sim_settings.copy() cfg_settings[ "scene"] = "data/scene_datasets/habitat-test-scenes/skokloster-castle.glb" # enable the physics simulator: also clears available actions to no-op cfg_settings["enable_physics"] = True cfg_settings["depth_sensor"] = True # test loading the physical scene hab_cfg = examples.settings.make_cfg(cfg_settings) with habitat_sim.Simulator(hab_cfg) as sim: obj_mgr = sim.get_object_template_manager() # make the simulation deterministic (C++ seed is set in reconfigure) np.random.seed(cfg_settings["seed"]) assert obj_mgr.get_num_templates() > 0 # test adding an object to the world obj_handle_list = obj_mgr.get_template_handles("cheezit") object_id = sim.add_object_by_handle(obj_handle_list[0]) object2_id = sim.add_object_by_handle(obj_handle_list[0]) # object_id = sim.add_object(1) # object2_id = sim.add_object(1) assert len(sim.get_existing_object_ids()) > 0 # place the objects over the table in room sim.set_translation(np.array([-0.569043, 2.04804, 13.6156]), object_id) sim.set_translation(np.array([-0.569043, 2.04804, 12.6156]), object2_id) # get object MotionType and continue testing if MotionType::DYNAMIC (implies a physics implementation is active) if (sim.get_object_motion_type(object_id) == habitat_sim.physics.MotionType.DYNAMIC): object1_init_template = sim.get_object_initialization_template( object_id) object1_mass = object1_init_template.mass grav = sim.get_gravity() previous_object_states = [ [sim.get_translation(object_id), sim.get_rotation(object_id)], [ sim.get_translation(object2_id), sim.get_rotation(object2_id) ], ] prev_time = sim.get_world_time() for _ in range(50): # force application at a location other than the origin should always cause angular and linear motion sim.apply_force(np.random.rand(3), np.random.rand(3), object2_id) # TODO: expose object properties (such as mass) to python # Counter the force of gravity on the object (it should not translate) sim.apply_force(-grav * object1_mass, np.zeros(3), object_id) # apply torque to the "floating" object. It should rotate, but not translate sim.apply_torque(np.random.rand(3), object_id) # TODO: test other physics functions # test getting observation sim.step( random.choice(list(hab_cfg.agents[0].action_space.keys()))) # check that time is increasing in the world assert sim.get_world_time() > prev_time prev_time = sim.get_world_time() # check the object states # 1st object should rotate, but not translate assert np.allclose(previous_object_states[0][0], sim.get_translation(object_id)) assert previous_object_states[0][1] != sim.get_rotation( object_id) # 2nd object should rotate and translate assert not np.allclose(previous_object_states[1][0], sim.get_translation(object2_id)) assert previous_object_states[1][1] != sim.get_rotation( object2_id) previous_object_states = [ [ sim.get_translation(object_id), sim.get_rotation(object_id) ], [ sim.get_translation(object2_id), sim.get_rotation(object2_id) ], ] # test setting DYNAMIC object to KINEMATIC assert sim.set_object_motion_type( habitat_sim.physics.MotionType.KINEMATIC, object2_id) assert (sim.get_object_motion_type(object2_id) == habitat_sim.physics.MotionType.KINEMATIC) sim.step(random.choice(list( hab_cfg.agents[0].action_space.keys()))) # 2nd object should no longer rotate or translate assert np.allclose(previous_object_states[1][0], sim.get_translation(object2_id)) assert previous_object_states[1][1] == sim.get_rotation(object2_id) sim.step_physics(0.1) # test velocity get/set test_lin_vel = np.array([1.0, 0.0, 0.0]) test_ang_vel = np.array([0.0, 1.0, 0.0]) # no velocity setting for KINEMATIC objects sim.set_linear_velocity(test_lin_vel, object2_id) assert sim.get_linear_velocity(object2_id) == np.array( [0.0, 0.0, 0.0]) sim.set_object_motion_type(habitat_sim.physics.MotionType.DYNAMIC, object2_id) sim.set_linear_velocity(test_lin_vel, object2_id) sim.set_angular_velocity(test_ang_vel, object2_id) assert sim.get_linear_velocity(object2_id) == test_lin_vel assert sim.get_angular_velocity(object2_id) == test_ang_vel # test modifying gravity new_object_start = np.array([100.0, 0, 0]) sim.set_translation(new_object_start, object_id) new_grav = np.array([10.0, 0, 0]) sim.set_gravity(new_grav) assert np.allclose(sim.get_gravity(), new_grav) assert np.allclose(sim.get_translation(object_id), new_object_start) sim.step_physics(0.1) assert sim.get_translation(object_id)[0] > new_object_start[0]
def reconfigure(self, config: Config) -> None: self.config = config is_same_sound = config.AGENT_0.SOUND == self._current_sound if not is_same_sound: self._current_sound = self.config.AGENT_0.SOUND is_same_scene = config.SCENE == self._current_scene if not is_same_scene: self._current_scene = config.SCENE logging.debug('Current scene: {} and sound: {}'.format( self.current_scene_name, self._current_sound)) if not self.config.USE_RENDERED_OBSERVATIONS: self._sim.close() del self._sim self.sim_config = self.create_sim_config(self._sensor_suite) self._sim = habitat_sim.Simulator(self.sim_config) self._update_agents_state() self._frame_cache = dict() else: with open(self.current_scene_observation_file, 'rb') as fo: self._frame_cache = pickle.load(fo) logging.debug('Loaded scene {}'.format(self.current_scene_name)) self.points, self.graph = load_metadata(self.metadata_dir) for node in self.graph.nodes(): self._position_to_index_mapping[self.position_encoding( self.graph.nodes()[node]['point'])] = node if not is_same_scene or not is_same_sound: self._audiogoal_cache = dict() self._spectrogram_cache = dict() self._episode_step_count = 0 # set agent positions self._receiver_position_index = self._position_to_index( self.config.AGENT_0.START_POSITION) self._source_position_index = self._position_to_index( self.config.AGENT_0.GOAL_POSITION) # the agent rotates about +Y starting from -Z counterclockwise, # so rotation angle 90 means the agent rotate about +Y 90 degrees self._rotation_angle = int( np.around( np.rad2deg( quat_to_angle_axis( quat_from_coeffs( self.config.AGENT_0.START_ROTATION))[0]))) % 360 if not self.config.USE_RENDERED_OBSERVATIONS: self.set_agent_state( list(self.graph.nodes[self._receiver_position_index]['point']), self.config.AGENT_0.START_ROTATION) else: self._sim.set_agent_state( list(self.graph.nodes[self._receiver_position_index]['point']), quat_from_coeffs(self.config.AGENT_0.START_ROTATION)) logging.debug( "Initial source, agent at: {}, {}, orientation: {}".format( self._source_position_index, self._receiver_position_index, self.get_orientation()))
args, _ = parser.parse_known_args() show_video = args.show_video make_video = args.make_video else: show_video = False make_video = False if make_video and not os.path.exists(output_path): os.mkdir(output_path) cfg = make_configuration() sim = None replay_filepath = output_path + "replay.json" if not sim: sim = habitat_sim.Simulator(cfg) else: sim.reconfigure(cfg) agent_state = habitat_sim.AgentState() agent = sim.initialize_agent(0, agent_state) # %% [markdown] # ## Initial placement for agent and sensor # %% agent_node = sim.get_agent(0).body.object sensor_node = sim._sensors["rgba_camera"]._sensor_object.object # initial agent transform agent_node.translation = [-0.15, -1.5, 1.0]
def main(): # We will define an action that moves the agent and turns it by some amount # First, define a class to keep the parameters of the control # @attr.s is just syntatic sugar for creating these data-classes @attr.s(auto_attribs=True, slots=True) class MoveAndSpinSpec: forward_amount: float spin_amount: float print(MoveAndSpinSpec(1.0, 45.0)) # Register the control functor # This action will be an action that effects the body, so body_action=True @habitat_sim.register_move_fn(body_action=True) class MoveForwardAndSpin(habitat_sim.SceneNodeControl): def __call__(self, scene_node: habitat_sim.SceneNode, actuation_spec: MoveAndSpinSpec): forward_ax = (np.array( scene_node.absolute_transformation().rotation_scaling()) @ habitat_sim.geo.FRONT) scene_node.translate_local(forward_ax * actuation_spec.forward_amount) # Rotate about the +y (up) axis rotation_ax = habitat_sim.geo.UP scene_node.rotate_local(mn.Deg(actuation_spec.spin_amount), rotation_ax) # Calling normalize is needed after rotating to deal with machine precision errors scene_node.rotation = scene_node.rotation.normalized() # We can also register the function with a custom name habitat_sim.register_move_fn(MoveForwardAndSpin, name="my_custom_name", body_action=True) # We can also re-register this function such that it effects just the sensors habitat_sim.register_move_fn(MoveForwardAndSpin, name="move_forward_and_spin_sensors", body_action=False) # Now we need to add this action to the agent's action space in the configuration! agent_config = habitat_sim.AgentConfiguration() _pprint(agent_config.action_space) # We can add the control function in a bunch of ways # Note that the name of the action does not need to match the name the control function # was registered under. # The habitat_sim.ActionSpec defines an action. The first arguement is the regsitered name # of the control spec, the second is the parameter spec agent_config.action_space["fwd_and_spin"] = habitat_sim.ActionSpec( "move_forward_and_spin", MoveAndSpinSpec(1.0, 45.0)) # Add the sensor version agent_config.action_space["fwd_and_spin_sensors"] = habitat_sim.ActionSpec( "move_forward_and_spin_sensors", MoveAndSpinSpec(1.0, 45.0)) # Add the same control with different parameters agent_config.action_space["fwd_and_spin_double"] = habitat_sim.ActionSpec( "move_forward_and_spin", MoveAndSpinSpec(2.0, 90.0)) # Use the custom name with an integer name for the action agent_config.action_space[100] = habitat_sim.ActionSpec( "my_custom_name", MoveAndSpinSpec(0.1, 1.0)) _pprint(agent_config.action_space) # Spin up the simulator backend_cfg = habitat_sim.SimulatorConfiguration() backend_cfg.scene.id = "data/scene_datasets/habitat-test-scenes/van-gogh-room.glb" sim = habitat_sim.Simulator( habitat_sim.Configuration(backend_cfg, [agent_config])) print(sim.get_agent(0).state) # Take the new actions! sim.step("fwd_and_spin") print(sim.get_agent(0).state) # Take the new actions! sim.step("fwd_and_spin_sensors") print(sim.get_agent(0).state) sim.step("fwd_and_spin_double") print(sim.get_agent(0).state) sim.step(100) print(sim.get_agent(0).state) sim.close() del sim # Let's define a strafe action! @attr.s(auto_attribs=True, slots=True) class StrafeActuationSpec: forward_amount: float # Classic strafing is to move perpendicular (90 deg) to the forward direction strafe_angle: float = 90.0 def _strafe_impl(scene_node: habitat_sim.SceneNode, forward_amount: float, strafe_angle: float): forward_ax = ( np.array(scene_node.absolute_transformation().rotation_scaling()) @ habitat_sim.geo.FRONT) rotation = habitat_sim.utils.quat_from_angle_axis( np.deg2rad(strafe_angle), habitat_sim.geo.UP) move_ax = habitat_sim.utils.quat_rotate_vector(rotation, forward_ax) scene_node.translate_local(move_ax * forward_amount) @habitat_sim.register_move_fn(body_action=True) class StrafeLeft(habitat_sim.SceneNodeControl): def __call__(self, scene_node: habitat_sim.SceneNode, actuation_spec: StrafeActuationSpec): _strafe_impl(scene_node, actuation_spec.forward_amount, actuation_spec.strafe_angle) @habitat_sim.register_move_fn(body_action=True) class StrafeRight(habitat_sim.SceneNodeControl): def __call__(self, scene_node: habitat_sim.SceneNode, actuation_spec: StrafeActuationSpec): _strafe_impl(scene_node, actuation_spec.forward_amount, -actuation_spec.strafe_angle) agent_config = habitat_sim.AgentConfiguration() agent_config.action_space["strafe_left"] = habitat_sim.ActionSpec( "strafe_left", StrafeActuationSpec(0.25)) agent_config.action_space["strafe_right"] = habitat_sim.ActionSpec( "strafe_right", StrafeActuationSpec(0.25)) sim = habitat_sim.Simulator( habitat_sim.Configuration(backend_cfg, [agent_config])) print(sim.get_agent(0).state) sim.step("strafe_left") print(sim.get_agent(0).state) sim.step("strafe_right") print(sim.get_agent(0).state)
def test_velocity_control(): cfg_settings = examples.settings.default_sim_settings.copy() cfg_settings["scene"] = "NONE" cfg_settings["enable_physics"] = True hab_cfg = examples.settings.make_cfg(cfg_settings) with habitat_sim.Simulator(hab_cfg) as sim: sim.set_gravity(np.array([0, 0, 0.0])) obj_mgr = sim.get_object_template_manager() template_path = osp.abspath("data/test_assets/objects/nested_box") template_ids = obj_mgr.load_object_configs(template_path) object_template = obj_mgr.get_template_by_ID(template_ids[0]) object_template.linear_damping = 0.0 object_template.angular_damping = 0.0 obj_mgr.register_template(object_template) obj_handle = obj_mgr.get_template_handle_by_ID(template_ids[0]) for iteration in range(2): sim.reset() object_id = sim.add_object_by_handle(obj_handle) vel_control = sim.get_object_velocity_control(object_id) if iteration == 0: if (sim.get_object_motion_type(object_id) != habitat_sim.physics.MotionType.DYNAMIC): # Non-dynamic simulator in use. Skip 1st pass. sim.remove_object(object_id) continue elif iteration == 1: # test KINEMATIC sim.set_object_motion_type( habitat_sim.physics.MotionType.KINEMATIC, object_id) # test global velocities vel_control.linear_velocity = np.array([1.0, 0, 0]) vel_control.angular_velocity = np.array([0, 1.0, 0]) vel_control.controlling_lin_vel = True vel_control.controlling_ang_vel = True while sim.get_world_time() < 1.0: # NOTE: stepping close to default timestep to get near-constant velocity control of DYNAMIC bodies. sim.step_physics(0.00416) ground_truth_pos = sim.get_world_time( ) * vel_control.linear_velocity assert np.allclose(sim.get_translation(object_id), ground_truth_pos, atol=0.01) ground_truth_q = mn.Quaternion([[0, 0.480551, 0], 0.876967]) angle_error = mn.math.angle(ground_truth_q, sim.get_rotation(object_id)) assert angle_error < mn.Rad(0.005) sim.reset() # test local velocities (turn in a half circle) vel_control.lin_vel_is_local = True vel_control.ang_vel_is_local = True vel_control.linear_velocity = np.array([0, 0, -math.pi]) vel_control.angular_velocity = np.array([math.pi * 2.0, 0, 0]) sim.set_translation(np.array([0, 0, 0.0]), object_id) sim.set_rotation(mn.Quaternion(), object_id) while sim.get_world_time() < 0.5: # NOTE: stepping close to default timestep to get near-constant velocity control of DYNAMIC bodies. sim.step_physics(0.008) print(sim.get_world_time()) # NOTE: explicit integration, so expect some error ground_truth_q = mn.Quaternion([[1.0, 0, 0], 0]) print(sim.get_translation(object_id)) assert np.allclose(sim.get_translation(object_id), np.array([0, 1.0, 0.0]), atol=0.07) angle_error = mn.math.angle(ground_truth_q, sim.get_rotation(object_id)) assert angle_error < mn.Rad(0.05) sim.remove_object(object_id)
def __init__( self, scene_filepath: Union[str, List[str]], labels: List[float] = None, img_size: tuple = (512, 512), output: List[str] = None, pose_extractor_name: str = "closest_point_extractor", sim=None, shuffle: bool = True, split: tuple = (70, 30), use_caching: bool = True, meters_per_pixel: float = 0.1, ): if labels is None: labels = [0.0] if output is None: output = ["rgba"] if sum(split) != 100: raise Exception("Train/test split must sum to 100.") self.scene_filepaths = None self.cur_fp = None if isinstance(scene_filepath, list): self.scene_filepaths = scene_filepath else: self.scene_filepaths = [scene_filepath] self.cur_fp = scene_filepath self.labels = set(labels) self.img_size = img_size self.cfg = self._config_sim(self.scene_filepaths[0], self.img_size) sim_provided = sim is not None if not sim_provided: sim = habitat_sim.Simulator(self.cfg) else: # If a sim is provided we have to make a new cfg self.cfg = self._config_sim(sim.config.sim_cfg.scene_id, img_size) sim.reconfigure(self.cfg) self.sim = sim self.meters_per_pixel = meters_per_pixel if not sim_provided: self.tdv_fp_ref_triples = self._preprocessing( self.sim, self.scene_filepaths, self.meters_per_pixel) else: ref_point = self._get_pathfinder_reference_point( self.sim.pathfinder) self.tdv_fp_ref_triples = [( TopdownView(self.sim, ref_point[1], meters_per_pixel), self.sim.config.sim_cfg.scene_id, ref_point, )] args = (self.tdv_fp_ref_triples, self.meters_per_pixel) self.pose_extractor = make_pose_extractor(pose_extractor_name)(*args) self.poses = self.pose_extractor.extract_all_poses() if shuffle: np.random.shuffle(self.poses) self.train, self.test = self._handle_split(split, self.poses) self.mode = "full" self.mode_to_data = { "full": self.poses, "train": self.train, "test": self.test, None: self.poses, } self.instance_id_to_name = self._generate_label_map( self.sim.semantic_scene) self.out_name_to_sensor_name = { "rgba": "color_sensor", "depth": "depth_sensor", "semantic": "semantic_sensor", } self.output = output self.use_caching = use_caching if self.use_caching: self.cache = ExtractorLRUCache()
def test_kinematics(): cfg_settings = examples.settings.default_sim_settings.copy() cfg_settings[ "scene"] = "data/scene_datasets/habitat-test-scenes/skokloster-castle.glb" # enable the physics simulator: also clears available actions to no-op cfg_settings["enable_physics"] = True cfg_settings["depth_sensor"] = True # test loading the physical scene hab_cfg = examples.settings.make_cfg(cfg_settings) with habitat_sim.Simulator(hab_cfg) as sim: obj_mgr = sim.get_object_template_manager() assert obj_mgr.get_num_templates() > 0 # test adding an object to the world # get handle for object 0, used to test obj_handle_list = obj_mgr.get_template_handles("cheezit") object_id = sim.add_object_by_handle(obj_handle_list[0]) assert len(sim.get_existing_object_ids()) > 0 # test setting the motion type assert sim.set_object_motion_type( habitat_sim.physics.MotionType.STATIC, object_id) assert (sim.get_object_motion_type(object_id) == habitat_sim.physics.MotionType.STATIC) assert sim.set_object_motion_type( habitat_sim.physics.MotionType.KINEMATIC, object_id) assert (sim.get_object_motion_type(object_id) == habitat_sim.physics.MotionType.KINEMATIC) # test kinematics I = np.identity(4) # test get and set translation sim.set_translation(np.array([0, 1.0, 0]), object_id) assert np.allclose(sim.get_translation(object_id), np.array([0, 1.0, 0])) # test object SceneNode object_node = sim.get_object_scene_node(object_id) assert np.allclose(sim.get_translation(object_id), object_node.translation) # test get and set transform sim.set_transformation(I, object_id) assert np.allclose(sim.get_transformation(object_id), I) # test get and set rotation Q = quat_from_angle_axis(np.pi, np.array([0, 1.0, 0])) expected = np.eye(4) expected[0:3, 0:3] = quaternion.as_rotation_matrix(Q) sim.set_rotation(quat_to_magnum(Q), object_id) assert np.allclose(sim.get_transformation(object_id), expected) assert np.allclose(quat_from_magnum(sim.get_rotation(object_id)), Q) # test object removal sim.remove_object(object_id) assert len(sim.get_existing_object_ids()) == 0 obj_handle_list = obj_mgr.get_template_handles("cheezit") object_id = sim.add_object_by_handle(obj_handle_list[0]) prev_time = 0.0 for _ in range(2): # do some kinematics here (todo: translating or rotating instead of absolute) sim.set_translation(np.random.rand(3), object_id) T = sim.get_transformation(object_id) # noqa : F841 # test getting observation sim.step(random.choice(list( hab_cfg.agents[0].action_space.keys()))) # check that time is increasing in the world assert sim.get_world_time() > prev_time prev_time = sim.get_world_time() sim.remove_object(object_id) # test attaching/dettaching an Agent to/from physics simulation agent_node = sim.agents[0].scene_node obj_handle_list = obj_mgr.get_template_handles("cheezit") object_id = sim.add_object_by_handle(obj_handle_list[0], agent_node) sim.set_translation(np.random.rand(3), object_id) assert np.allclose(agent_node.translation, sim.get_translation(object_id)) sim.remove_object(object_id, False) # don't delete the agent's node assert agent_node.translation # test get/set RigidState object_id = sim.add_object_by_handle(obj_handle_list[0]) targetRigidState = habitat_sim.bindings.RigidState( mn.Quaternion(), np.array([1.0, 2.0, 3.0])) sim.set_rigid_state(targetRigidState, object_id) objectRigidState = sim.get_rigid_state(object_id) assert np.allclose(objectRigidState.translation, targetRigidState.translation) assert objectRigidState.rotation == targetRigidState.rotation
def runVHACDSimulation(obj_path): # data will store data from simulation data = { "observations": [], } cfg = make_configuration() with habitat_sim.Simulator(cfg) as sim: sim.initialize_agent( 0, habitat_sim.AgentState( [5.45, 2.4, 1.2], np.quaternion(1, 0, 0, 0), ), ) # get the physics object attributes manager obj_templates_mgr = sim.get_object_template_manager() # create a list that will store the object ids obj_ids = [] # get object template & render asset handle obj_id_1 = obj_templates_mgr.load_configs( str(os.path.join(data_path, obj_path)))[0] obj_template = obj_templates_mgr.get_template_by_ID(obj_id_1) obj_handle = obj_template.render_asset_handle obj_templates_mgr.register_template(obj_template, force_registration=True) obj_ids += [obj_id_1] # == VHACD == # Now, create a new object template based on the recently created obj_template # specify parameters for running CHD # high resolution params = habitat_sim._ext.habitat_sim_bindings.VHACDParameters() params.resolution = 200000 params.max_convex_hulls = 32 # run VHACD, with params passed in and render new_handle_1 = sim.apply_convex_hull_decomposition( obj_handle, params, True, True) new_obj_template_1 = obj_templates_mgr.get_template_by_handle( new_handle_1) obj_templates_mgr.register_template(new_obj_template_1, force_registration=True) obj_ids += [new_obj_template_1.ID] # Medium resolution params = habitat_sim.VHACDParameters() params.resolution = 100000 params.max_convex_hulls = 4 # run VHACD, with params passed in and render new_handle_2 = sim.apply_convex_hull_decomposition( obj_handle, params, True, True) new_obj_template_2 = obj_templates_mgr.get_template_by_handle( new_handle_2) obj_templates_mgr.register_template(new_obj_template_2, force_registration=True) obj_ids += [new_obj_template_2.ID] # Low resolution params = habitat_sim.VHACDParameters() params.resolution = 10000 params.max_convex_hulls = 1 # run VHACD, with params passed in and render new_handle_3 = sim.apply_convex_hull_decomposition( obj_handle, params, True, True) new_obj_template_3 = obj_templates_mgr.get_template_by_handle( new_handle_3) obj_templates_mgr.register_template(new_obj_template_3, force_registration=True) obj_ids += [new_obj_template_3.ID] # now display objects cur_ids = [] for i in range(len(obj_ids)): cur_id = sim.add_object(obj_ids[i]) cur_ids.append(cur_id) # get length obj_node = sim.get_object_scene_node(cur_id) obj_bb = obj_node.cumulative_bb length = obj_bb.size().length() * 0.8 total_length = length * len(obj_ids) dist = math.sqrt(3) * total_length / 2 set_object_state_from_agent( sim, cur_id, offset=np.array([ -total_length / 2 + total_length * i / (len(obj_ids) - 1), 1.4, -1 * dist, ]), ) sim.set_object_motion_type( habitat_sim.physics.MotionType.KINEMATIC, cur_id) vel_control = sim.get_object_velocity_control(cur_id) vel_control.controlling_ang_vel = True vel_control.angular_velocity = np.array([0, -1.56, 0]) # simulate for 4 seconds simulate(sim, dt=4, get_frames=True, data=data) for cur_id in cur_ids: vel_control = sim.get_object_velocity_control(cur_id) vel_control.controlling_ang_vel = True vel_control.angular_velocity = np.array([-1.56, 0, 0]) # simulate for 4 seconds simulate(sim, dt=4, get_frames=True, data=data) return data
def test_get_no_light_setup(make_cfg_settings): with habitat_sim.Simulator(make_cfg(make_cfg_settings)) as sim: assert len(sim.get_light_setup(NO_LIGHT_KEY)) == 0
args, _ = parser.parse_known_args() show_video = args.show_video make_video = args.make_video if make_video and not os.path.exists(output_path): os.mkdir(output_path) # %% # [initialize] # create the simulators AND resets the simulator cfg = make_configuration() try: # Got to make initialization idiot proof sim.close() except NameError: pass sim = habitat_sim.Simulator(cfg) agent_transform = place_agent(sim) # get the primitive assets attributes manager prim_templates_mgr = sim.get_asset_template_manager() # get the physics object attributes manager obj_templates_mgr = sim.get_object_template_manager() # [/initialize] # %% # [basics] # load some object templates from configuration files sphere_template_id = obj_templates_mgr.load_configs( str(os.path.join(data_path, "test_assets/objects/sphere")))[0]
def box_drop_test( args, objects, num_objects=30, box_size=2, object_speed=2, post_throw_settling_time=5, useVHACD=False, VHACDParams=def_params, ): # take in parameters here """Drops a specified number of objects into a box and returns metrics including the time to simulate each frame, render each frame, and the number of collisions each frame.""" data = { "observations": [], "physics_step_times": [], "graphics_render_times": [], "collisions": [], } cfg = make_configuration() with habitat_sim.Simulator(cfg) as sim: sim.initialize_agent( 0, habitat_sim.AgentState( [5.45 * box_size, 2.4 * box_size, 1.2 * box_size], np.quaternion(-0.8000822, 0.1924500, -0.5345973, -0.1924500), ), ) # get the physics object attributes manager obj_templates_mgr = sim.get_object_template_manager() # build box cube_handle = obj_templates_mgr.get_template_handles("cube")[0] box_parts = [] boxIDs = [] for _i in range(5): box_parts += [ obj_templates_mgr.get_template_by_handle(cube_handle) ] box_parts[0].scale = np.array([1.0, 0.1, 1.0]) * box_size box_parts[1].scale = np.array([1.0, 0.6, 0.1]) * box_size box_parts[2].scale = np.array([1.0, 0.6, 0.1]) * box_size box_parts[3].scale = np.array([0.1, 0.6, 1.0]) * box_size box_parts[4].scale = np.array([0.1, 0.6, 1.0]) * box_size for i in range(5): part_name = "box_part_" + str(i) obj_templates_mgr.register_template(box_parts[i], part_name) boxIDs += [sim.add_object_by_handle(part_name)] sim.set_object_motion_type( habitat_sim.physics.MotionType.KINEMATIC, boxIDs[i]) sim.set_translation(np.array([2.50, 0.05, 0.4]) * box_size, boxIDs[0]) sim.set_translation(np.array([2.50, 0.35, 1.30]) * box_size, boxIDs[1]) sim.set_translation( np.array([2.50, 0.35, -0.50]) * box_size, boxIDs[2]) sim.set_translation(np.array([3.40, 0.35, 0.4]) * box_size, boxIDs[3]) sim.set_translation(np.array([1.60, 0.35, 0.4]) * box_size, boxIDs[4]) for i in range(5): sim.set_object_motion_type(habitat_sim.physics.MotionType.STATIC, boxIDs[i]) # load some object templates from configuration files object_ids = [] for obj in objects: obj_path = obj["path"] object_ids += [ obj_templates_mgr.load_configs( str(os.path.join(data_path, obj_path)))[0] ] obj_template = obj_templates_mgr.get_template_by_ID(object_ids[-1]) if "scale" in obj: obj_template.scale *= obj["scale"] obj_handle = obj_template.render_asset_handle if useVHACD: new_handle = sim.apply_convex_hull_decomposition( obj_handle, VHACDParams, True, False) new_obj_template = obj_templates_mgr.get_template_by_handle( new_handle) if "scale" in obj: new_obj_template.scale *= obj["scale"] obj_templates_mgr.register_template(new_obj_template, force_registration=True) object_ids[-1] = new_obj_template.ID print("Template Registered") else: obj_templates_mgr.register_template(obj_template, force_registration=True) # throw objects into box for i in range(num_objects): cur_id = sim.add_object(object_ids[i % len(object_ids)]) obj_node = sim.get_object_scene_node(cur_id) obj_bb = obj_node.cumulative_bb diagonal_length = obj_bb.size().length() time_til_next_obj = diagonal_length / (object_speed * box_size) / 2 # set object position and velocity sim.set_translation( np.multiply(np.array([1.50, 2, 1.2]), box_size), cur_id) sim.set_linear_velocity( mn.Vector3(1, 0, -1).normalized() * object_speed * box_size, cur_id) # simulate a short amount of time, then add next object simulate(sim, dt=time_til_next_obj, get_frames=args.make_video, data=data) simulate(sim, dt=post_throw_settling_time, get_frames=args.make_video, data=data) # [/basics] # return total time to run, time to load, time to simulate physics, time for rendering remove_all_objects(sim) return data