def vis_top_down_render_with_panda_render(): setup_logger(True) env = TopDownSingleFramePGDriveEnv({ "environment_num": 1, "manual_control": True, "use_render": True, "use_image": False, "traffic_mode": "respawn" }) o = env.reset() s = time.time() for i in range(1, 100000): o, r, d, info = env.step(env.action_space.sample()) env.render( text={ "vehicle_num": len(env.scene_manager.traffic_manager.vehicles), "traffic_vehicle": len(env.scene_manager.traffic_manager.traffic_vehicles) }) # if d: # env.reset() if i % 1000 == 0: print("Steps: {}, Time: {}".format(i, time.time() - s)) env.close()
def _vis(): setup_logger(True) env = MultiAgentPGDrive( { "use_render": True, "fast": True, "num_agents": 5, "start_seed": 8000, "environment_num": 1, "map": "SSS", # "allow_respawn": False, # "manual_control": True, } ) o = env.reset() total_r = 0 for i in range(1, 100000): # o, r, d, info = env.step(env.action_space.sample()) o, r, d, info = env.step({v_id: [0.0, 0.0] for v_id in env.vehicles.keys()}) for r_ in r.values(): total_r += r_ # o, r, d, info = env.step([0,1]) # d.update({"total_r": total_r}) env.render(mode="top_down") # env.reset() if len(env.vehicles) == 0: total_r = 0 print("Reset") env.reset() env.close()
def test_traffic_respawn(vis=False): setup_logger(vis) env = PGDriveEnv( { "environment_num": 1, "manual_control": vis, "use_render": vis, "use_topdown": True, "traffic_mode": "respawn" } ) env.reset() try: for i in range(1, 3000): env.step([0, 0]) current_v = set(env.engine.traffic_manager.vehicles) for v in list(env.engine.traffic_manager.traffic_vehicles) + [env.vehicle]: if v is env.vehicle: current_v.discard(v) else: current_v.discard(v) assert len(current_v) == 0, "vehicles didn't release" assert len(env.engine.traffic_manager.vehicles) - len(env.engine.traffic_manager.traffic_vehicles) == 1, \ "vehicles didn't release" finally: env.close()
def _test(): setup_logger(True) env = MultiAgentPGDrive( { "num_agents": 12, "allow_respawn": False, "use_render": True, "debug": False, "fast": True, "manual_control": True, } ) o = env.reset() total_r = 0 for i in range(1, 100000): # o, r, d, info = env.step(env.action_space.sample()) o, r, d, info = env.step({v_id: [0, 1] for v_id in env.vehicles.keys()}) for r_ in r.values(): total_r += r_ # o, r, d, info = env.step([0,1]) d.update({"total_r": total_r}) # env.render(text=d) env.render(mode="top_down") if len(env.vehicles) == 0: total_r = 0 print("Reset") env.reset() env.close()
def test_save_episode(vis=False): setup_logger(True) test_dump = False env = TestEnv(vis=vis) try: o = env.reset() epi_info = None for i in range(1, 100000 if vis else 2000): o, r, d, info = env.step([0, 1]) if vis: env.render() if d: epi_info = env.scene_manager.dump_episode() # test dump json if test_dump: with open("test.json", "w") as f: json.dump(epi_info, f) break o = env.reset(epi_info) for i in range(1, 100000 if vis else 2000): o, r, d, info = env.step([0, 1]) if vis: env.render() if d: break finally: env.close()
def test_gen_map_read(): setup_logger(debug=True) env = PGDriveEnv({"environment_num": 10, "load_map_from_json": False}) try: data = env.dump_all_maps() with open("test_10maps.json", "w") as f: json.dump(data, f) with open("test_10maps.json", "r") as f: restored_data = json.load(f) env.close() env = PGDriveEnv({ "environment_num": 10, }) env.lazy_init() print("Start loading.") env.engine.map_manager.read_all_maps(restored_data) while any([v is None for v in env.maps.values()]): env.reset() for i in range(10): m = env.maps[i].save_map() recursive_equal(m, data["map_data"][i], need_assert=True) print("Finish!") finally: env.close()
def test_save_map_image(): os.makedirs("tmp_images", exist_ok=True) setup_logger(debug=True) env = PGDriveEnv(dict(environment_num=20, start_seed=0, map=10)) try: for i in range(5): env.reset() surface = draw_top_down_map(env.current_map, resolution=(128, 128)) plt.imshow(surface, cmap="Greys") plt.savefig("tmp_images/map_{}.png".format(i)) env.close() finally: env.close()
def test_save_episode(vis=False): """ 1. Set record_episode=True to record each episode 2. dump_episode when done[__all__] == True 3. You can keep recent episodes 4. Input episode data to reset() function can replay the episode ! """ setup_logger(True) test_dump = True dump_recent_episode = 5 dump_count = 0 env = MultiAgentRoundaboutEnv( dict(use_render=vis, manual_control=vis, record_episode=True, horizon=100)) try: # Test Record o = env.reset() epi_info = None for i in range(1, 100000 if vis else 600): o, r, d, info = env.step( {agent_id: [0, .2] for agent_id in env.vehicles.keys()}) if vis: env.render() if d["__all__"]: epi_info = env.engine.dump_episode() # test dump json if test_dump: with open("test_dump_{}.json".format(dump_count), "w") as f: json.dump(epi_info, f) dump_count += 1 dump_count = dump_count % dump_recent_episode env.reset() # input episode_info to restore o = env.reset(epi_info) for i in range(1, 100000 if vis else 2000): o, r, d, info = env.step( {agent_id: [0, 0.1] for agent_id in env.vehicles.keys()}) if vis: env.render() if d["__all__"]: break finally: env.close()
def test_lidar_with_mask(render=False): setup_logger(debug=True) env = PGDriveEnv({ "use_render": render, "manual_control": render, "environment_num": 1, "traffic_density": 0.3, "vehicle_config": { "show_lidar": True, "side_detector": dict(num_lasers=2, distance=50), "lane_line_detector": dict(num_lasers=2, distance=50), }, "_disable_detector_mask": False, "map": "XXX" }) try: env.reset() v_config = env.config["vehicle_config"] v_config["spawn_longitude"] = 0 v_config["spawn_lateral"] = 7.5 another_v = DefaultVehicle(v_config, random_seed=0) another_v.reset() # for test objs = env.vehicle.side_detector.perceive( env.vehicle, env.vehicle.engine.physics_world.static_world ).detected_objects + env.vehicle.lane_line_detector.perceive( env.vehicle, env.vehicle.engine.physics_world.static_world).detected_objects yellow = 0 for obj in objs: if obj.getNode().getName() == BodyName.Yellow_continuous_line: yellow += 1 assert yellow == 2, "side detector and lane detector broken" detect_traffic_vehicle = False detect_base_vehicle = False for i in range(1, 100000): o, r, d, info = env.step([0, 1]) if len( env.vehicle.lidar.get_surrounding_vehicles( env.observations[DEFAULT_AGENT].detected_objects)) > 2: detect_traffic_vehicle = True for hit in env.observations[DEFAULT_AGENT].detected_objects: if isinstance(hit, BaseVehicle): detect_base_vehicle = True if d: break if not (detect_traffic_vehicle and detect_base_vehicle): print("Lidar detection failed") assert detect_traffic_vehicle and detect_base_vehicle, "Lidar detection failed" finally: env.close()
def test_lidar_with_mask(render=False): setup_logger(debug=True) env = TestEnv( { "use_render": render, "manual_control": render, "environment_num": 1, "traffic_density": 0.3, "vehicle_config": { "show_lidar": True, "side_detector": dict(num_lasers=2, distance=50), "lane_line_detector": dict(num_lasers=2, distance=50), }, "_disable_detector_mask": False } ) try: env.reset() vehicle = env.vehicle v_config = env.config["vehicle_config"] v_config["spawn_longitude"] = 80 v_config["spawn_lateral"] = 5 another_v = BaseVehicle(env.pg_world, v_config) another_v.reset(env.current_map) # for test env.agent_manager._pending_objects[another_v.name] = another_v objs = vehicle.side_detector.get_detected_objects() + vehicle.lane_line_detector.get_detected_objects() yellow = 0 for obj in objs: if obj.getNode().getName() == BodyName.Yellow_continuous_line: yellow += 1 assert yellow == 2, "side detector and lane detector broken" detect_traffic_vehicle = False detect_base_vehicle = False for i in range(1, 100000): o, r, d, info = env.step([0, 1]) if len(vehicle.lidar.get_surrounding_vehicles()) > 4: detect_traffic_vehicle = True for hit in vehicle.lidar.get_detected_objects(): v = hit.getNode() if v.hasPythonTag(BodyName.Base_vehicle): detect_base_vehicle = True if d: break if not (detect_traffic_vehicle and detect_base_vehicle): print("Lidar detection failed") assert detect_traffic_vehicle and detect_base_vehicle, "Lidar detection failed" finally: env.close()
def test_save_episode(vis=False): setup_logger(True) test_dump = True save_episode = True, vis = True env = PGDriveEnv( { "environment_num": 1, "traffic_density": 0.1, "start_seed": 5, # "manual_control": vis, "use_render": vis, "traffic_mode": TrafficMode.Trigger, "record_episode": save_episode, "map_config": { BaseMap.GENERATE_TYPE: MapGenerateMethod.BIG_BLOCK_SEQUENCE, BaseMap.GENERATE_CONFIG: "XTXTXTXTXT", BaseMap.LANE_WIDTH: 3.5, BaseMap.LANE_NUM: 3, } } ) try: o = env.reset() epi_info = None for i in range(1, 100000 if vis else 2000): o, r, d, info = env.step([0, 1]) if vis: env.render() if d: epi_info = env.engine.dump_episode() # test dump json if test_dump: with open("test.json", "w") as f: json.dump(epi_info, f) break o = env.reset(epi_info) for i in range(1, 100000 if vis else 2000): o, r, d, info = env.step([0, 1]) if vis: env.render() if d: break finally: env.close()
def test_save_map_image(): os.makedirs("tmp_images", exist_ok=True) setup_logger(debug=True) env = PGDriveEnv(dict(environment_num=20, start_seed=0, map=10)) try: for i in range(5): env.reset() surface = env.get_map(resolution=(128, 128)) plt.imshow(surface, cmap="Greys") plt.savefig("tmp_images/map_{}.png".format(i)) env.current_map.draw_navi_line(env.vehicle, dest_resolution=(2048, 2048), save=False) env.close() finally: env.close()
def vis_highway_render_with_panda_render(): setup_logger(True) env = PGDriveEnv({ "environment_num": 1, "manual_control": True, "use_render": True, "use_image": False, "use_topdown": True, }) o = env.reset() s = time.time() for i in range(1, 100000): o, r, d, info = env.step(env.action_space.sample()) env.render() if d: env.reset() if i % 1000 == 0: print("Steps: {}, Time: {}".format(i, time.time() - s)) env.close()
import time from pgdrive import PGDriveEnv from pgdrive.utils import setup_logger if __name__ == '__main__': setup_logger(debug=False) env = PGDriveEnv(dict( environment_num=1000, # use_render=True, fast=True, start_seed=1010, pstats=True )) obs = env.reset() start = time.time() action = [0.0, 1.] for s in range(10000000): o, r, d, i = env.step(action) if d: env.reset() if (s + 1) % 100 == 0: print( "Finish {}/10000 simulation steps. Time elapse: {:.4f}. Average FPS: {:.4f}".format( s + 1, time.time() - start, (s + 1) / (time.time() - start) ) ) print(f"Total Time Elapse: {time.time() - start}")
config={ "use_render": True, "map": "SSS", "num_agents": 4, "manual_control": True, "target_vehicle_configs": { "agent{}".format(i): { "spawn_longitude": i * 5 } for i in range(4) } }) if __name__ == "__main__": setup_logger(True) env = TestEnv() o = env.reset() print("vehicle num", len(env.engine.traffic_manager.vehicles)) for i in range(1, 100000): o, r, d, info = env.step( {key: [0, 0] for key in env.action_space.sample()}) # o, r, d, info = env.step([0,1]) env.render( text={"display_regions": len(env.engine.win.getDisplayRegions())}) if True in d.values(): print("Reset") env.reset() env.close()
def __init__(self, config: dict = None): # Setup config and Panda3d self.pg_config = self.default_config() if config is not None: self.pg_config.update(config) if self.pg_config["pstats"]: # pstats debug provided by panda3d loadPrcFileData("", "want-pstats 1") loadPrcFileData("", "win-size {} {}".format(*self.pg_config["window_size"])) # Setup onscreen render if self.pg_config["use_render"]: self.mode = RENDER_MODE_ONSCREEN # Warning it may cause memory leak, Pand3d Official has fixed this in their master branch. # You can enable it if your panda version is latest. loadPrcFileData("", "threading-model Cull/Draw") # multi-thread render, accelerate simulation when evaluate else: if self.pg_config["use_image"]: self.mode = RENDER_MODE_OFFSCREEN else: self.mode = RENDER_MODE_NONE if is_mac() and (self.mode == RENDER_MODE_OFFSCREEN): # Mac don't support offscreen rendering self.mode = RENDER_MODE_ONSCREEN # Setup some debug options if self.pg_config["headless_image"]: # headless machine support loadPrcFileData("", "load-display pandagles2") if self.pg_config["debug"]: # debug setting PGWorld.DEBUG = True _free_warning() setup_logger(debug=True) self.accept('1', self.toggleDebug) self.accept('2', self.toggleWireframe) self.accept('3', self.toggleTexture) self.accept('4', self.toggleAnalyze) else: # only report fatal error when debug is False _suppress_warning() # a special debug mode if self.pg_config["debug_physics_world"]: self.accept('1', self.toggleDebug) super(PGWorld, self).__init__(windowType=self.mode) # Change window size at runtime if screen too small assert int(self.pg_config["use_topdown"]) + int(self.pg_config["use_image"]) <= 1, ( "Only one of use_topdown and use_image options can be selected." ) main_window_position = (0, 0) if self.mode == RENDER_MODE_ONSCREEN: loadPrcFileData("", "compressed-textures 1") # Default to compress h = self.pipe.getDisplayHeight() w = self.pipe.getDisplayWidth() if self.pg_config["window_size"][0] > 0.9 * w or self.pg_config["window_size"][1] > 0.9 * h: old_scale = self.pg_config["window_size"][0] / self.pg_config["window_size"][1] new_w = int(min(0.9 * w, 0.9 * h * old_scale)) new_h = int(min(0.9 * h, 0.9 * w / old_scale)) self.pg_config["window_size"] = tuple([new_w, new_h]) from panda3d.core import WindowProperties props = WindowProperties() props.setSize(self.pg_config["window_size"][0], self.pg_config["window_size"][1]) self.win.requestProperties(props) logging.warning( "Since your screen is too small ({}, {}), we resize the window to {}.".format( w, h, self.pg_config["window_size"] ) ) main_window_position = ( (w - self.pg_config["window_size"][0]) / 2, (h - self.pg_config["window_size"][1]) / 2 ) self.highway_render = None if self.pg_config["use_topdown"]: self.highway_render = HighwayRender(self.pg_config["use_render"], main_window_position) # screen scale factor self.w_scale = max(self.pg_config["window_size"][0] / self.pg_config["window_size"][1], 1) self.h_scale = max(self.pg_config["window_size"][1] / self.pg_config["window_size"][0], 1) if self.mode == RENDER_MODE_ONSCREEN: self.disableMouse() if not self.pg_config["debug_physics_world"] and (self.mode in [RENDER_MODE_ONSCREEN, RENDER_MODE_OFFSCREEN]): initialize_asset_loader(self) gltf.patch_loader(self.loader) # Display logo if self.mode == RENDER_MODE_ONSCREEN: self._loading_logo = OnscreenImage( image=AssetLoader.file_path("PGDrive-large.png"), pos=(0, 0, 0), scale=(self.w_scale, 1, self.h_scale) ) self._loading_logo.setTransparency(True) for i in range(20): self.graphicsEngine.renderFrame() self.taskMgr.add(self.remove_logo, "remove _loading_logo in first frame") self.closed = False # add element to render and pbr render, if is exists all the time. # these element will not be removed when clear_world() is called self.pbr_render = self.render.attachNewNode("pbrNP") # attach node to this root root whose children nodes will be clear after calling clear_world() self.worldNP = self.render.attachNewNode("world_np") # same as worldNP, but this node is only used for render gltf model with pbr material self.pbr_worldNP = self.pbr_render.attachNewNode("pbrNP") self.debug_node = None # some render attr self.pbrpipe = None self.light = None self.collision_info_np = None # physics world self.physics_world = PGPhysicsWorld() # for real time simulation self.force_fps = ForceFPS(self, start=False) # init terrain self.terrain = Terrain() self.terrain.attach_to_pg_world(self.render, self.physics_world) # init other world elements if self.mode != RENDER_MODE_NONE: from pgdrive.world.our_pbr import OurPipeline self.pbrpipe = OurPipeline( render_node=None, window=None, camera_node=None, msaa_samples=4, max_lights=8, use_normal_maps=False, use_emission_maps=True, exposure=1.0, enable_shadows=False, enable_fog=False, use_occlusion_maps=False ) self.pbrpipe.render_node = self.pbr_render self.pbrpipe.render_node.set_antialias(AntialiasAttrib.M_auto) self.pbrpipe._recompile_pbr() self.pbrpipe.manager.cleanup() # set main cam self.cam.node().setCameraMask(CamMask.MainCam) self.cam.node().getDisplayRegion(0).setClearColorActive(True) self.cam.node().getDisplayRegion(0).setClearColor(ImageBuffer.BKG_COLOR) lens = self.cam.node().getLens() lens.setFov(70) lens.setAspectRatio(1.2) self.sky_box = SkyBox() self.sky_box.attach_to_pg_world(self.render, self.physics_world) self.light = Light(self.pg_config) self.light.attach_to_pg_world(self.render, self.physics_world) self.render.setLight(self.light.direction_np) self.render.setLight(self.light.ambient_np) self.render.setShaderAuto() self.render.setAntialias(AntialiasAttrib.MAuto) # ui and render property if self.pg_config["show_fps"]: self.setFrameRateMeter(True) # onscreen message self.on_screen_message = PGOnScreenMessage( debug=self.DEBUG ) if self.mode == RENDER_MODE_ONSCREEN and self.pg_config["onscreen_message"] else None self._show_help_message = False self._episode_start_time = time.time() self.accept("h", self.toggle_help_message) self.accept("f", self.force_fps.toggle) else: self.on_screen_message = None # task manager self.taskMgr.remove('audioLoop')
from pgdrive.component.map.base_map import BaseMap, MapGenerateMethod from pgdrive.envs.pgdrive_env import PGDriveEnv from pgdrive.utils import setup_logger setup_logger(debug=True) if __name__ == "__main__": env = PGDriveEnv({ "environment_num": 4, "traffic_density": 0.1, "start_seed": 3, "image_source": "mini_map", "manual_control": True, "use_render": True, "offscreen_render": False, "decision_repeat": 5, "rgb_clip": True, "map_config": { BaseMap.GENERATE_TYPE: MapGenerateMethod.BIG_BLOCK_NUM, BaseMap.GENERATE_CONFIG: 12, BaseMap.LANE_WIDTH: 3.5, BaseMap.LANE_NUM: 3, } }) env.reset() for i in range(1, 100000): o, r, d, info = env.step([0, 1]) env.render(text={"Frame": i, "Speed": env.vehicle.speed}) env.close()