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()
