def dump_all_maps(self):
assert not engine_initialized(), \
"We assume you generate map files in independent tasks (not in training). " \
"So you should run the generating script without calling reset of the " \
"environment."
self.lazy_init() # it only works the first time when reset() is called to avoid the error when render
assert engine_initialized()
for seed in range(self.start_seed, self.start_seed + self.env_num):
all_config = self.config.copy()
all_config["map_config"]["seed"] = seed
# map_config = copy.deepcopy(self.config["map_config"])
# map_config.update({"seed": seed})
# set_global_random_seed(seed)
self.engine.map_manager.update_map(all_config, current_seed=seed)
# new_map = self.engine.map_manager.spawn_object(PGMap, map_config=map_config, random_seed=None)
# self.pg_maps[current_seed] = new_map
# self.engine.map_manager.unload_map(new_map)
print("Finish generating map with seed: {}".format(seed))
map_data = dict()
for seed, map in self.maps.items():
assert map is not None
map_data[seed] = map.save_map()
return_data = dict(map_config=self.config["map_config"].copy().get_dict(), map_data=copy.deepcopy(map_data))
return return_data
def __init__(self):
from pgdrive.engine.engine_utils import get_engine, engine_initialized
assert engine_initialized(
), "You should not create manager before the initialization of BaseEngine"
self.engine = get_engine()
Randomizable.__init__(self, self.engine.global_random_seed)
self.spawned_objects = {}
def __init__(self):
assert engine_initialized(
), "You should initialize engine before adding camera to vehicle"
config = get_global_config()["vehicle_config"]["rgb_camera"]
self.BUFFER_W, self.BUFFER_H = config[0], config[1]
super(RGBCamera, self).__init__()
cam = self.get_cam()
lens = self.get_lens()
cam.lookAt(0, 2.4, 1.3)
lens.setFov(60)
lens.setAspectRatio(2.0)
def __init__(self):
assert engine_initialized(
), "You should initialize engine before adding camera to vehicle"
config = get_global_config()["vehicle_config"]["depth_camera"]
self.BUFFER_W, self.BUFFER_H = config[0], config[1]
self.VIEW_GROUND = config[2]
super(DepthCamera, self).__init__()
cam = self.get_cam()
lens = self.get_lens()
cam.lookAt(0, 2.4, 1.3)
lens.setFov(60)
lens.setAspectRatio(2.0)
if get_engine(
).mode == RENDER_MODE_NONE or not AssetLoader.initialized():
return
# add shader for it
if get_global_config()["headless_machine_render"]:
vert_path = AssetLoader.file_path("shaders",
"depth_cam_gles.vert.glsl")
frag_path = AssetLoader.file_path("shaders",
"depth_cam_gles.frag.glsl")
else:
from pgdrive.utils import is_mac
if is_mac():
vert_path = AssetLoader.file_path("shaders",
"depth_cam_mac.vert.glsl")
frag_path = AssetLoader.file_path("shaders",
"depth_cam_mac.frag.glsl")
else:
vert_path = AssetLoader.file_path("shaders",
"depth_cam.vert.glsl")
frag_path = AssetLoader.file_path("shaders",
"depth_cam.frag.glsl")
custom_shader = Shader.load(Shader.SL_GLSL,
vertex=vert_path,
fragment=frag_path)
cam.node().setInitialState(
RenderState.make(ShaderAttrib.make(custom_shader, 1)))
if self.VIEW_GROUND:
self.GROUND = GeoMipTerrain("mySimpleTerrain")
self.GROUND.setHeightfield(
AssetLoader.file_path("textures", "height_map.png"))
# terrain.setBruteforce(True)
# # Since the terrain is a texture, shader will not calculate the depth information, we add a moving terrain
# # model to enable the depth information of terrain
self.GROUND_MODEL = self.GROUND.getRoot()
self.GROUND_MODEL.setPos(-128, 0, self.GROUND_HEIGHT)
self.GROUND_MODEL.hide(CamMask.AllOn)
self.GROUND_MODEL.show(CamMask.DepthCam)
self.GROUND.generate()
def __init__(self):
assert engine_initialized(), "You should initialize engine before adding camera to vehicle"
config = get_global_config()["vehicle_config"]["mini_map"]
self.BUFFER_W, self.BUFFER_H = config[0], config[1]
height = config[2]
super(MiniMap, self).__init__()
cam = self.get_cam()
lens = self.get_lens()
cam.setZ(height)
cam.lookAt(Vec3(0, 20, 0))
lens.setAspectRatio(2.0)
def lazy_init(self):
"""
Only init once in runtime, variable here exists till the close_env is called
:return: None
"""
# It is the true init() func to create the main vehicle and its module, to avoid incompatible with ray
if engine_initialized():
return
self.engine = initialize_engine(self.config)
# engine setup
self.setup_engine()
# other optional initialization
self._after_lazy_init()
def __init__(
self,
vehicle_config: Union[dict, Config] = None,
name: str = None,
random_seed=None,
):
"""
This Vehicle Config is different from self.get_config(), and it is used to define which modules to use, and
module parameters. And self.physics_config defines the physics feature of vehicles, such as length/width
:param vehicle_config: mostly, vehicle module config
:param random_seed: int
"""
# check
assert vehicle_config is not None, "Please specify the vehicle config."
assert engine_initialized(
), "Please make sure game engine is successfully initialized!"
# NOTE: it is the game engine, not vehicle drivetrain
self.engine = get_engine()
BaseObject.__init__(self, name, random_seed,
self.engine.global_config["vehicle_config"])
BaseVehicleState.__init__(self)
self.update_config(vehicle_config)
am_i_the_special_one = self.config["am_i_the_special_one"]
# build vehicle physics model
vehicle_chassis = self._create_vehicle_chassis()
self.add_body(vehicle_chassis.getChassis())
self.system = vehicle_chassis
self.chassis = self.origin
self.wheels = self._create_wheel()
# powertrain config
self.increment_steering = self.config["increment_steering"]
self.enable_reverse = self.config["enable_reverse"]
self.max_speed = self.config["max_speed"]
self.max_steering = self.config["max_steering"]
# visualization
color = sns.color_palette("colorblind")
idx = get_np_random().randint(len(color))
rand_c = color[idx]
if am_i_the_special_one:
rand_c = color[2] # A pretty green
self.top_down_color = (rand_c[0] * 255, rand_c[1] * 255,
rand_c[2] * 255)
self.panda_color = rand_c
self._add_visualization()
# modules, get observation by using these modules
self.lane: Optional[AbstractLane] = None
self.lane_index = None
self.navigation: Optional[Navigation] = None
self.lidar: Optional[Lidar] = None # detect surrounding vehicles
self.side_detector: Optional[SideDetector] = None # detect road side
self.lane_line_detector: Optional[
LaneLineDetector] = None # detect nearest lane lines
self.image_sensors = {}
# state info
self.throttle_brake = 0.0
self.steering = 0
self.last_current_action = deque([(0.0, 0.0), (0.0, 0.0)], maxlen=2)
self.last_position = (0, 0)
self.last_heading_dir = self.heading
self.dist_to_left_side = None
self.dist_to_right_side = None
# step info
self.out_of_route = None
self.on_lane = None
self.spawn_place = (0, 0)
self._init_step_info()
# others
self._add_modules_for_vehicle()
self.takeover = False
self.expert_takeover = False
self.energy_consumption = 0
self.action_space = self.get_action_space_before_init(
extra_action_dim=self.config["extra_action_dim"])
self.break_down = False
# overtake_stat
self.front_vehicles = set()
self.back_vehicles = set()
if self.engine.current_map is not None:
self.reset()