def __enter__(self):
self._settings = self.world.get_settings()
self.frame = self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=self.delta_seconds))
def make_queue(register_event):
"""
This queuing has nothing to do with (sequential) programming, it only stores the data in queues.
Different types of data are stored in different queues.
Each register event(in this case, world.on_tick and sensor.Listen) takes a Queue.put() method as callback,
which then also takes data (Worldsnapshot or SensorData in this case) as argument
so that each time these events are called the correspondent data would be save to queues.
:param register_event: a function that takes a callback as argument
:return:
"""
q = queue.Queue()
register_event(q.put)
self._queues.append(q)
make_queue(self.world.on_tick)
for sensor in self.sensors:
make_queue(sensor.listen)
return self
def setUp(self):
super(TestSynchronousMode, self).setUp()
self.world = self.client.get_world()
self.settings = self.world.get_settings()
settings = carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True)
self.world.apply_settings(settings)
def test_reloading_map(self):
settings = carla.WorldSettings(
no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=0.05)
for _ in range(0, 4):
self.world = self.client.reload_world()
self.world.apply_settings(settings)
def setUp(self):
super(SyncSmokeTest, self).setUp()
self.world = self.client.get_world()
self.settings = self.world.get_settings()
settings = carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=0.05)
self.world.apply_settings(settings)
def apply_settings(self, fps=10.0, no_rendering=False):
self.delta_seconds = 1.0 / fps
self._settings = self.world.get_settings()
self.frame = self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=no_rendering,
synchronous_mode=True,
fixed_delta_seconds=self.delta_seconds))
def set_synchronous_mode(self, synchronous_mode):
"""
Sets synchronous mode.
"""
self.world.apply_settings(carla.WorldSettings(
no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=self.delta_seconds))
def setUp(self):
super(TestCollisionDeterminism, self).setUp()
self.world = self.client.get_world()
self.settings = self.world.get_settings()
settings = carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=0.05)
self.world.apply_settings(settings)
self.world.tick()
def __enter__(self):
self._settings = self.world.get_settings()
self.frame = self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=False,
fixed_delta_seconds=self.delta_seconds,
synchronous_mode=True))
for sensor in self.sensors.values():
sensor.start()
return self
def test_spawn_points(self):
self.world = self.client.get_world()
blueprints = self.world.get_blueprint_library().filter("vehicle.*")
# get all available maps
maps = self.client.get_available_maps()
for m in maps:
# load the map
self.client.load_world(m)
self.world = self.client.get_world()
# get all spawn points
spawn_points = self.world.get_map().get_spawn_points()
# Check why the world settings aren't applied after a reload
self.settings = self.world.get_settings()
settings = carla.WorldSettings(
no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=0.05)
self.world.apply_settings(settings)
# spawn all kind of vehicle
for vehicle in blueprints:
batch = [(vehicle, t) for t in spawn_points]
batch = [carla.command.SpawnActor(*args) for args in batch]
response = self.client.apply_batch_sync(batch, True)
self.assertFalse(any(x.error for x in response))
ids = [x.actor_id for x in response]
self.assertEqual(len(ids), len(spawn_points))
frame = self.world.tick()
snapshot = self.world.get_snapshot()
self.assertEqual(frame, snapshot.timestamp.frame)
actors = self.world.get_actors()
self.assertTrue(all(snapshot.has_actor(x.id) for x in actors))
for actor_id, t0 in zip(ids, spawn_points):
actor_snapshot = snapshot.find(actor_id)
self.assertIsNotNone(actor_snapshot)
t1 = actor_snapshot.get_transform()
# Ignore Z cause vehicle is falling.
self.assertAlmostEqual(t0.location.x, t1.location.x, places=2)
self.assertAlmostEqual(t0.location.y, t1.location.y, places=2)
self.assertAlmostEqual(t0.rotation.pitch, t1.rotation.pitch, places=2)
self.assertAlmostEqual(t0.rotation.yaw, t1.rotation.yaw, places=2)
self.assertAlmostEqual(t0.rotation.roll, t1.rotation.roll, places=2)
self.client.apply_batch_sync([carla.command.DestroyActor(x) for x in ids], True)
frame = self.world.tick()
def test_reloading_map(self):
print("TestSynchronousMode.test_reloading_map")
settings = carla.WorldSettings(
no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=0.05)
for _ in range(0, 4):
self.world = self.client.reload_world()
self.world.apply_settings(settings)
# workaround: give time to UE4 to clean memory after loading (old assets)
time.sleep(5)
def __enter__(self):
self._settings = self.world.get_settings()
self.frame = self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=True, synchronous_mode=True))
def make_queue(register_event):
q = queue.Queue()
register_event(q.put)
self._queues.append(q)
make_queue(self.world.on_tick)
for sensor in self.sensors:
make_queue(sensor.listen)
return self
def start(self):
self._settings = self.world.get_settings()
self.frame = self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=self.delta_seconds))
def make_queue(register_event):
q = queue.Queue()
register_event(q.put)
self._queues.append(q)
make_queue(self.world.on_tick)
for sensor in self.sensors:
make_queue(sensor.listen)
def _initialize_world_settings(self):
"""Applies the simulator settings"""
self.settings = self.world.get_settings()
_ = self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=self.no_rendering_mode,
synchronous_mode=self.sync_mode,
fixed_delta_seconds=self.delta_sec))
if self.sync_mode:
print("Synchronous Mode enabled")
else:
print("Synchronous Mode disabled")
if self.no_rendering_mode:
print("No Rendering Mode enabled (==camera sensors are disabled)")
else:
print("No Rendering Mode disabled")
def reloadWorld(self, envParams: EnvSetupParams):
self.world = self.client.get_world()
if self.world is None or self.world.get_map(
) is None or self.world.get_map().name != envParams.mapToUse:
self.client.load_world(envParams.mapToUse)
else:
self.client.reload_world()
self.envParams = envParams
# Set settings for this episode and reload the world
settings = carla.WorldSettings(
no_rendering_mode=self.args.no_rendering,
synchronous_mode=envParams.synchronousComm,
fixed_delta_seconds=1.0 / envParams.fixedFPS)
# settings.randomize_seeds()
self.world.apply_settings(settings)
self.map = self.world.get_map()
def __enter__(self):
self._settings = self.world.get_settings()
self.frame = self.world.apply_settings(carla.WorldSettings(
no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=self.delta_seconds))
def make_queue(register_event):
q = queue.Queue()
register_event(q.put)
self._queues.append(q)
make_queue(self.world.on_tick)
for sensor in self.sensors:
actor = self.world.get_actor(sensor) if type(sensor) is int else sensor
make_queue(actor.listen)
return self
def __init__(self):
try:
carla_base.__init__(self)
self.world = self.client.load_world('Town04')
self.world.apply_settings(
carla.WorldSettings(
no_rendering_mode=base_config.no_render_mode))
except:
raise RuntimeError('carla_base init fails...')
else:
if env_v1_config.fix_vehicle_pos:
## using predefine vehicles position
self.vehicles_pos = np.load(
env_v1_config.vehicles_pos_file)['pos']
else:
## random generate vehicles position
self.vehicles_pos = generate_vehicles_pos(
n_vehicles=random.randint(27, 27))
if env_v1_config.synchronous_mode:
self.start_synchronous_mode()
# ------ 设置动作空间大小 ----------- #
self.action_space = spaces.Discrete(
len(list(env_v1_config.actions.keys())))
# ----
self.max_step = 2000
self.step_counter = 0
# end_point
self.end_point_x = 50.
# max velocity
self.longitude_velocity_norm = 6. ## m/s, 归一化尺度
self.lateral_velocity_norm = 1.5 ## m/s, 归一化尺度
self.__longitude_norm = env_v1_config.farest_vehicle_consider ## 纵向方向上的归一化尺度
##
self.n_been_catched_record = 0
self.test_mode = False
self.left_obstacle = None
self.right_obstacle = None
def __enter__(self):
# some data about the simulation such as synchrony between client and server or rendering mode
self._settings = self.world.get_settings()
# ---- This is important carla.WorldSettings
self.frame = self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=self.delta_seconds))
def make_queue(register_event):
q = queue.Queue()
register_event(q.put)
self._queues.append(q)
make_queue(self.world.on_tick)
for sensor in self.sensors:
make_queue(sensor.listen)
return self
def __enter__(self):
self._settings = self.world.get_settings()
self.frame = self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=self.delta_seconds))
def make_queue(register_event):
q = queue.Queue()
register_event(q.put)
self._queues.append(q)
make_queue(self.world.on_tick)
make_queue(self.camera_rgb.listen)
make_queue(self.camera_lidar.listen)
# make_queue(self.sensor_collision.listen)
return self
def test_spawn_points(self):
print("TestSnapshot.test_spawn_points")
self.world = self.client.reload_world()
# workaround: give time to UE4 to clean memory after loading (old assets)
time.sleep(5)
# Check why the world settings aren't applied after a reload
self.settings = self.world.get_settings()
settings = carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=0.05)
self.world.apply_settings(settings)
spawn_points = self.world.get_map().get_spawn_points()[:20]
vehicles = self.world.get_blueprint_library().filter('vehicle.*')
batch = [(random.choice(vehicles), t) for t in spawn_points]
batch = [carla.command.SpawnActor(*args) for args in batch]
response = self.client.apply_batch_sync(batch, False)
self.assertFalse(any(x.error for x in response))
ids = [x.actor_id for x in response]
self.assertEqual(len(ids), len(spawn_points))
frame = self.world.tick()
snapshot = self.world.get_snapshot()
self.assertEqual(frame, snapshot.timestamp.frame)
actors = self.world.get_actors()
self.assertTrue(all(snapshot.has_actor(x.id) for x in actors))
for actor_id, t0 in zip(ids, spawn_points):
actor_snapshot = snapshot.find(actor_id)
self.assertIsNotNone(actor_snapshot)
t1 = actor_snapshot.get_transform()
# Ignore Z cause vehicle is falling.
self.assertAlmostEqual(t0.location.x, t1.location.x, places=2)
self.assertAlmostEqual(t0.location.y, t1.location.y, places=2)
self.assertAlmostEqual(t0.rotation.pitch,
t1.rotation.pitch,
places=2)
self.assertAlmostEqual(t0.rotation.yaw, t1.rotation.yaw, places=2)
self.assertAlmostEqual(t0.rotation.roll,
t1.rotation.roll,
places=2)
def __init__(self):
self.client = carla.Client("localhost", 2000)
self.client.set_timeout(2.0)
self.world = self.client.get_world()
self.world = self.client.reload_world()
self.map = self.world.get_map()
self.blueprint_library = self.world.get_blueprint_library()
self.model_3 = self.blueprint_library.filter("model3")[0]
self.vehicle = None
# world in sync mode
self.world.apply_settings(
carla.WorldSettings(
no_rendering_mode=NO_RENDERING, # False for debug
synchronous_mode=True,
fixed_delta_seconds=DT_))
pygame.init()
self.display = pygame.display.set_mode(
(800, 600), pygame.HWSURFACE | pygame.DOUBLEBUF)
self.font = get_font()
self.clock = pygame.time.Clock()
def __enter__(self):
self._settings = self.world.get_settings()
self.frame = self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=self.delta_seconds))
def make_queue_snapshot(register_event):
q = queue.Queue()
register_event(q.put)
self._queues.append((q, 'carla.WorldSnapshot'))
def make_queue_sensor(sensor, register_event):
q = queue.Queue()
register_event(q.put)
# self._queues.append((q, sensor.type_id))
self._queues.append((q, sensor[1]))
make_queue_snapshot(self.world.on_tick)
for sensor in self.sensors:
# make_queue_sensor(sensor, sensor.listen)
make_queue_sensor(sensor, sensor[0].listen)
return self
def main():
try:
client = carla.Client('localhost', 2000)
client.set_timeout(2.0)
load_world_if_needed(client, "/Game/Carla/Maps/Town01")
world = client.get_world()
world.apply_settings(carla.WorldSettings(True, False, 1.0 / 30))
map = world.get_map()
start_tf = carla.Transform(carla.Location(x=230, y=55, z=0.1),
carla.Rotation(0, 180, 0))
start_wp = map.get_waypoint(start_tf.location)
end_loc = carla.Location(x=240, y=55, z=0)
waypoints = find_waypoins(
start_wp,
[10, 172, 25, 32, 2, 88, 21, 188, 22, 158, 4, 141, 17, 114, 10], 1,
end_loc)
print('waypoint count ', len(waypoints))
route_line = LineString([(wp.transform.location.x,
wp.transform.location.y)
for wp in waypoints])
blueprint_library = world.get_blueprint_library()
bp = blueprint_library.find('vehicle.jeep.wrangler_rubicon')
vehicle = world.spawn_actor(bp, start_tf)
print('created %s' % vehicle.type_id)
print('===============')
print('physics_control')
print(vehicle.get_physics_control())
#vehicle.set_velocity(carla.Vector3D(-10, 0, 0)) # 초기 속도를 지정할 수 있다.
while True:
curr_tf = vehicle.get_transform()
curr_location = vehicle.get_location()
curr_velocity = vehicle.get_velocity()
waypoint = map.get_waypoint(curr_location)
vehicle.apply_control(
my_control(curr_tf, curr_velocity, route_line))
frame = world.tick()
print(f"frame={frame}, road_id={waypoint.road_id}")
spectator_tf = carla.Transform(
carla.Location(curr_location.x, curr_location.y,
curr_location.z + 2.5), curr_tf.rotation)
world.get_spectator().set_transform(spectator_tf)
if curr_location.distance(end_loc) < 3: break
print("success")
finally:
print('destroying vehicle')
vehicle.destroy()
# synchronous_mode를 해제한다.
world.apply_settings(carla.WorldSettings(False))
print('done.')
'win-amd64' if os.name == 'nt' else 'linux-x86_64'))[0])
except IndexError:
pass
import carla
import random
import time
if __name__=='__main__':
try:
client = carla.Client('localhost', 2000)
client.set_timeout(3.0)
world = client.get_world()
previous_settings = world.get_settings()
world.apply_settings(carla.WorldSettings(
synchronous_mode=True,
fixed_delta_seconds=1.0 / 10.0))
spawn_points = world.get_map().get_spawn_points()
blueprint_library = world.get_blueprint_library()
vehicle_bp = random.choice(blueprint_library.filter('vehicle.toyota.*'))
actors = []
print("number of spawn points: {}".format(len(spawn_points)))
for i in range(len(spawn_points)):
actor = world.try_spawn_actor(vehicle_bp, spawn_points[i % len(spawn_points)])
if actor==None:
continue
actor.set_autopilot()
actors.append(actor)
last_number = 0
while True:
def main(self):
try:
# initialize one painter
try:
self.painter = CarlaPainter('localhost', 8089)
except Exception as e:
print("NO PAINTER")
print(e)
self.painter = None
self.client = carla.Client('localhost', 2000)
self.client.set_timeout(10.0)
self.world = self.client.get_world()
# set synchronous mode
previous_settings = self.world.get_settings()
self.world.apply_settings(
carla.WorldSettings(synchronous_mode=True,
fixed_delta_seconds=1.0 / 30.0))
# spawn an ego vehicle
spawn_points = self.world.get_map().get_spawn_points()
blueprints_vehicles = self.world.get_blueprint_library().filter(
"vehicle.*")
ego_transform = spawn_points[0]
blueprints_vehicles = [
x for x in blueprints_vehicles
if int(x.get_attribute('number_of_wheels')) == 4
]
# set ego vehicle's role name to let CarlaViz know this vehicle is the ego vehicle
blueprints_vehicles[0].set_attribute('role_name',
'ego') # or set to 'hero'
batch = [
carla.command.SpawnActor(blueprints_vehicles[0],
ego_transform).then(
carla.command.SetAutopilot(
carla.command.FutureActor,
False))
]
results = self.client.apply_batch_sync(batch, False)
if not results[0].error:
self.ego_vehicle = self.world.get_actor(results[0].actor_id)
else:
print('spawn ego error, exit')
self.ego_vehicle = None
return
# attach a camera and a lidar to the ego vehicle
#blueprint_camera = self.world.get_blueprint_library().find('sensor.camera.rgb')
#blueprint_camera.set_attribute('image_size_x', '640')
#blueprint_camera.set_attribute('image_size_y', '480')
#blueprint_camera.set_attribute('fov', '110')
#blueprint_camera.set_attribute('sensor_tick', '0.1')
#transform_camera = carla.Transform(carla.Location(x=.3, z=1.8))
#self.camera = self.world.spawn_actor(blueprint_camera, transform_camera, attach_to=self.ego_vehicle)
#self.camera.listen(lambda data: self.camera_listener(data))
blueprint_lidar = self.world.get_blueprint_library().find(
'sensor.lidar.ray_cast')
# these specs follow the velodyne vlp32 spec
blueprint_lidar.set_attribute('range', '200')
#blueprint_lidar.set_attribute('range', '30')
blueprint_lidar.set_attribute('rotation_frequency', '10')
blueprint_lidar.set_attribute('channels', '32')
blueprint_lidar.set_attribute('lower_fov', '-25')
blueprint_lidar.set_attribute('upper_fov', '15')
blueprint_lidar.set_attribute('points_per_second', '578560')
self.blueprint_lidar = blueprint_lidar
transform_lidar = carla.Transform(carla.Location(x=0.0, z=1.8))
self.lidar = self.world.spawn_actor(blueprint_lidar,
transform_lidar,
attach_to=self.ego_vehicle)
self.lidar.listen(lambda data: self.lidar_listener(data))
# tick to generate these actors in the game world
self.world.tick()
# save vehicles' trajectories to draw in the frontend
trajectories = [[]]
self.obstacle = None
#self.obstacle = self.spawn_obstacle()
while (True):
self.world.tick()
strs = []
locs = []
loc = self.ego_vehicle.get_location()
strs.append("{:.2f}, ".format(loc.x) + "{:.2f}".format(loc.y) \
+ ", {:.2f}".format(loc.z))
locs.append([loc.x, loc.y, loc.z + 10.0])
strs.append( "{:.2f}, ".format(loc.x-self.certificate_distance) + "{:.2f}".format(loc.y) \
+ ", {:.2f}".format(loc.z))
locs.append(
[loc.x - self.certificate_distance, loc.y, loc.z + 10.0])
strs.append("Certificate GOOD" if self.
certificate_result else "Certificate BAD")
locs.append([loc.x - 5, loc.y - 5, loc.z + 20.0])
self.painter.draw_texts(strs, locs, size=20)
##@trajectories[0].append([ego_location.x, ego_location.y, ego_location.z])
## draw trajectories
#painter.draw_polylines(trajectories)
## draw ego vehicle's velocity just above the ego vehicle
#ego_velocity = ego_vehicle.get_velocity()
#velocity_str = "{:.2f}, ".format(ego_velocity.x) + "{:.2f}".format(ego_velocity.y) \
# + ", {:.2f}".format(ego_velocity.z)
finally:
if previous_settings is not None:
self.world.apply_settings(previous_settings)
if self.lidar is not None:
self.lidar.stop()
self.lidar.destroy()
if self.camera is not None:
self.camera.stop()
self.camera.destroy()
if self.ego_vehicle is not None:
self.ego_vehicle.destroy()
if self.obstacle is not None:
self.obstacle.destroy()
def setup(
town: str,
weather: str,
fps: int = 20,
server_timestop: float = 20.0,
client_timeout: float = 20.0,
num_max_restarts: int = 5,
) -> Tuple[carla.Client, carla.World, int, subprocess.Popen]: # pylint: disable=no-member
"""Returns the `CARLA` `server`, `client` and `world`.
Args:
town: The `CARLA` town identifier.
fps: The frequency (in Hz) of the simulation.
server_timestop: The time interval between spawing the server
and resuming program.
client_timeout: The time interval before stopping
the search for the carla server.
num_max_restarts: Number of attempts to connect to the server.
Returns:
client: The `CARLA` client.
world: The `CARLA` world.
frame: The synchronous simulation time step ID.
server: The `CARLA` server.
"""
assert town in ("Town01", "Town02", "Town03", "Town04", "Town05")
# All preset weather parameters in carla.WeatherParameters
assert weather in ("ClearNoon", "CloudyNoon", "WetNoon", "WetCloudyNoon",
"SoftRainNoon", "MidRainyNoon", "HardRainNoon",
"ClearSunset", "CloudySunset", "WetSunset",
"WetCloudySunset", "SoftRainSunset", "MidRainSunset",
"HardRainSunset")
weather_params = getattr(carla.WeatherParameters, weather)
# The attempts counter.
attempts = 0
while attempts < num_max_restarts:
logging.debug(
"{} out of {} attempts to setup the CARLA simulator".format(
attempts + 1, num_max_restarts))
# Random assignment of port.
port = np.random.randint(2000, 3000)
# Start CARLA server.
env = os.environ.copy()
env["SDL_VIDEODRIVER"] = "offscreen"
env["SDL_HINT_CUDA_DEVICE"] = "1"
logging.debug("Inits a CARLA server at port={}".format(port))
server = subprocess.Popen(
[
os.path.join(os.environ.get("CARLA_ROOT"), "CarlaUE4.sh"),
"-carla-rpc-port={}".format(port),
"-quality-level=Epic",
],
stdout=None,
stderr=subprocess.STDOUT,
preexec_fn=os.setsid,
env=env,
)
atexit.register(os.killpg, server.pid, signal.SIGKILL)
time.sleep(server_timestop)
# Connect client.
logging.debug("Connects a CARLA client at port={}".format(port))
try:
client = carla.Client("localhost", port) # pylint: disable=no-member
client.set_timeout(client_timeout)
client.load_world(map_name=town)
world = client.get_world()
world.set_weather(weather_params) # pylint: disable=no-member
frame = world.apply_settings(
carla.WorldSettings( # pylint: disable=no-member
no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=1.0 / fps,
))
logging.debug("Server version: {}".format(
client.get_server_version()))
logging.debug("Client version: {}".format(
client.get_client_version()))
return client, world, frame, server
except RuntimeError as msg:
logging.debug(msg)
attempts += 1
logging.debug("Stopping CARLA server at port={}".format(port))
os.killpg(server.pid, signal.SIGKILL)
atexit.unregister(lambda: os.killpg(server.pid, signal.SIGKILL))
logging.debug("Failed to connect to CARLA after {} attempts".format(
num_max_restarts))
sys.exit()
def __init__(self, address='localhost', port=2000, timeout=2.0, image_shape=(150, 200, 3), window_size=(800, 600),
vehicle_filter='vehicle.*', sensors: dict = None, route_resolution=2.0, fps=30.0, render=True,
debug=False):
"""
:param address: CARLA simulator's id address. Required only if the simulator runs on a different machine.
:param port: CARLA simulator's port.
:param timeout: connection timeout.
:param image_shape: shape of the images observations.
:param window_size: pygame's window size. Meaningful only if `visualize=True`.
:param vehicle_filter: use to spawn a particular vehicle (e.g. 'vehicle.tesla.model3') or class of vehicles
(e.g. 'vehicle.audi.*')
:param sensors: specifies which sensors should be equipped to the vehicle, better specified by subclassing
`default_sensors()`.
:param route_resolution: route planner resolution grain.
:param fps: maximum framerate, it depends on your compiting power.
:param render: if True a pygame window is shown.
:param debug: enable to display some useful information about the vehicle.
"""
super().__init__()
env_utils.init_pygame()
self.timeout = timeout
self.client = env_utils.get_client(address, port, self.timeout)
self.world: carla.World = self.client.get_world()
self.map: carla.Map = self.world.get_map()
self.synchronous_context = None
# set fix fps:
self.world.apply_settings(carla.WorldSettings(
no_rendering_mode=False,
synchronous_mode=False,
fixed_delta_seconds=1.0 / fps))
# vehicle
self.vehicle_filter = vehicle_filter
self.vehicle: carla.Vehicle = None
# actions
self.control: carla.VehicleControl = None
self.prev_actions = None
# weather
# TODO: add weather support
# visualization and debugging stuff
self.image_shape = image_shape
self.image_size = (image_shape[1], image_shape[0])
self.DEFAULT_IMAGE = np.zeros(shape=self.image_shape, dtype=np.float32)
self.fps = fps
self.tick_time = 1.0 / self.fps
self.should_render = render
self.should_debug = debug
self.clock = pygame.time.Clock()
if self.should_render:
self.window_size = window_size
self.font = env_utils.get_font(size=13)
self.display = env_utils.get_display(window_size)
# variables for reward computation
self.collision_penalty = 0.0
# vehicle sensors suite
self.sensors_spec = sensors if isinstance(sensors, dict) else self.default_sensors()
self.sensors = dict()
def close_synchronous_mode(self):
"""close synchoronous mode"""
self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=base_config.no_render_mode,
synchronous_mode=False))
def start_synchronous_mode(self):
"""carla synchoronous mode"""
self.world.apply_settings(
carla.WorldSettings(no_rendering_mode=base_config.no_render_mode,
synchronous_mode=True))
def main(self, case):
try:
# connect to Carla engine
self.client = carla.Client('localhost', 2000)
self.client.set_timeout(10.0)
self.world = self.client.get_world()
previous_settings = self.world.get_settings()
self.world.apply_settings(carla.WorldSettings(
synchronous_mode=True,
fixed_delta_seconds=1.0 / 20.0))
self.tm = self.client.get_trafficmanager()
self.tm.set_synchronous_mode(True)
self.tm_port = self.tm.get_port()
# create interlock starting scenario
results = case(self.tm_port, self.client.apply_batch_sync, self.world)
self.vehicles.extend(results[1:])
if not results[0].error:
self.ego_vehicle = self.world.get_actor(results[0].actor_id)
self.ego_id = results[0].actor_id
else:
print('spawn ego error, exit')
self.ego_vehicle = None
return
# attach a camera and a lidar to the ego vehicle
self.blueprint_camera = self.world.get_blueprint_library().find('sensor.camera.rgb')
self.blueprint_camera.set_attribute('image_size_x', '1200')
self.blueprint_camera.set_attribute('image_size_y', '400')
self.blueprint_camera.set_attribute('fov', '120')
#self.blueprint_camera.set_attribute('sensor_tick', '0.1')
transform_camera = carla.Transform(carla.Location(x=.0, z=1.8))
self.camera = self.world.spawn_actor(self.blueprint_camera, transform_camera, attach_to=self.ego_vehicle)
self.camera.listen(lambda data: self.camera_listener(data))
self.blueprint_lidar = self.world.get_blueprint_library().find('sensor.lidar.ray_cast_semantic')
self.blueprint_lidar.set_attribute('range', '200000')
self.blueprint_lidar.set_attribute('rotation_frequency', '20')
#self.blueprint_lidar.set_attribute('channels', '64') # 0.6/0.4 resolution
self.blueprint_lidar.set_attribute('channels', '192') # 0.2/0.2 resolution
#self.blueprint_lidar.set_attribute('channels', '402')# 0.1/0.1 resolution
self.blueprint_lidar.set_attribute('lower_fov', '-25')
self.blueprint_lidar.set_attribute('upper_fov', '15')
#self.blueprint_lidar.set_attribute('points_per_second', '1200000')# 0.6/0.4 resolution
self.blueprint_lidar.set_attribute('points_per_second', '7200000')# 0.2/0.2 resolution
#self.blueprint_lidar.set_attribute('points_per_second', '28860000')# 0.1/0.1 resolution
transform_lidar = carla.Transform(carla.Location(x=0.0, z=1.8))
self.lidar = self.world.spawn_actor(self.blueprint_lidar, transform_lidar, attach_to=self.ego_vehicle)
self.lidar.listen(lambda data: self.lidar_listener(data))
# attach semantic segmentation camera to ego
blueprint_camera_segmentation = self.world.get_blueprint_library().find('sensor.camera.semantic_segmentation')
blueprint_camera_segmentation.set_attribute('image_size_x', str(self.blueprint_camera.get_attribute("image_size_x").as_int()))
blueprint_camera_segmentation.set_attribute('image_size_y', str(self.blueprint_camera.get_attribute("image_size_y").as_int()))
blueprint_camera_segmentation.set_attribute('fov', str(self.blueprint_camera.get_attribute("fov").as_float()))
self.camera_segmentation = self.world.spawn_actor(blueprint_camera_segmentation, transform_camera, attach_to=self.ego_vehicle)
self.camera_segmentation.listen(lambda data: self.camera_segmentation_listener(data))
# tick to generate these actors in the game world
self.world.tick()
self.certificate_result = True
while (True):
self.frame += 1
self.world.tick()
self.sensor_processor()
if not self.certificate_result:
self.world.get_actor(self.ego_id).apply_control(carla.VehicleControl(brake=1.0))
finally:
if previous_settings is not None:
self.world.apply_settings(previous_settings)
if self.lidar is not None:
self.lidar.stop()
self.lidar.destroy()
if self.camera is not None:
self.camera.stop()
self.camera.destroy()
if self.camera_segmentation is not None:
self.camera_segmentation.stop()
self.camera_segmentation.destroy()
if self.ego_vehicle is not None:
self.ego_vehicle.destroy()
self.client.apply_batch([carla.command.DestroyActor(x.actor_id) for x in self.vehicles])
def main():
worlds = ["Town02"]
# worlds = ["Town01", "Town02", "Town03", "Town04", "Town05"]
client = carla.Client("127.0.0.1", 2000)
client.set_timeout(10.0)
traffic_manager: carla.TrafficManager = client.get_trafficmanager()
traffic_manager.set_global_distance_to_leading_vehicle(2.0)
traffic_manager.global_percentage_speed_difference(25.0)
# traffic_manager.set_hybrid_physics_mode(True)
# traffic_manager.set_synchronous_mode(True)
for world_name in worlds:
print(f"Loading {world_name}")
client.load_world(world_name)
world: carla.World = client.get_world()
start_frame = world.apply_settings(
carla.WorldSettings(no_rendering_mode=False,
synchronous_mode=True,
fixed_delta_seconds=1 / FPS))
weather = Weather(carla.WeatherParameters.ClearNoon)
world.set_weather(weather.weather)
vehicle_spawner = VehicleSpawner(client, world, False)
vehicle_spawner.spawn_nearby(0, 40, 40, 40, 80, 1000000)
print("Running the world for 5 seconds before capturing...")
frame = start_frame
while frame < start_frame + FPS * 5:
frame = world.tick()
print("Starting capture!")
all_sensors: List[carla.Sensor] = []
vehicle_sensor_queues: Dict[int, Dict[str, Tuple[Queue,
carla.Sensor]]] = {}
for vehicle_id in vehicle_spawner.vehicles_list:
vehicle = world.get_actor(vehicle_id)
sensors = spawn_sensors(world, vehicle)
for sensor_name, sensor in sensors.items():
all_sensors.append(sensor)
queue = Queue()
sensor.listen(queue.put)
if vehicle_id not in vehicle_sensor_queues:
vehicle_sensor_queues[vehicle_id] = {}
vehicle_sensor_queues[vehicle_id][sensor_name] = (queue,
sensor)
while frame < start_frame + FPS * 5:
frame = world.tick()
for i in range(0, NUMBER_OF_IMAGES_PER_VEHICLE_PER_WORLD):
weather.tick(1)
world.set_weather(weather.weather)
frame = world.tick()
print(f"Tick ({frame})")
for vehicle_id, vehicle_sensors in vehicle_sensor_queues.items():
new_yaw = random.gauss(0, 45)
frame_nums = []
for sensor_name, (queue, sensor) in vehicle_sensors.items():
try:
image = retrieve_data(frame, queue, TIMEOUT)
print(f"Got image from {sensor_name} {image.frame}")
frame_nums.append(image.frame)
image.save_to_disk(
f"output_perception/{world_name}/{sensor_name}/{vehicle_id}_{image.frame}.png",
get_color_converter(sensor_name))
sensor.set_transform(
carla.Transform(carla.Location(0, 0, 3),
carla.Rotation(0, new_yaw, 0)))
except Empty:
print("Empty queue")
assert all(frame == frame_nums[0] for frame in frame_nums)
# Run amount of ticks equal to the sensors' sensor_tick value
settings = world.get_settings()
settings.no_rendering_mode = True
world.apply_settings(settings)
for t in range(0, int(SENSOR_TICK * FPS) - 8):
weather.tick(1 / FPS * 5)
world.set_weather(weather.weather)
frame = world.tick()
print(f"Tick ({frame})")
settings.no_rendering_mode = False
world.apply_settings(settings)
# Do rest of ticks with rendering (to hopefully get rain effect)
for i in range(0, 8):
weather.tick(1 / FPS * 5)
world.set_weather(weather.weather)
frame = world.tick()
print(f"Tick ({frame})")
# Clean up
# traffic_manager.set_synchronous_mode(False)
for sensor in all_sensors:
sensor.destroy()
vehicle_spawner.destroy_vehicles()
