def _initialize_actors(self, config):
"""
Custom initialization
"""
if self._randomize:
self._distance = random.randint(low=10, high=80, size=3)
self._distance = sorted(self._distance)
else:
self._distance = [14, 48, 74]
self._reference_waypoint = self._map.get_waypoint(
config.trigger_points[0].location)
# Get the debris locations
first_wp, _ = get_waypoint_in_distance(self._reference_waypoint,
self._distance[0])
first_ground_loc = self.world.ground_projection(
first_wp.transform.location, 2)
self.first_loc_prev = first_ground_loc.location if first_ground_loc else first_wp.transform.location
second_wp, _ = get_waypoint_in_distance(self._reference_waypoint,
self._distance[1])
second_ground_loc = self.world.ground_projection(
second_wp.transform.location, 2)
self.second_loc_prev = second_ground_loc.location if second_ground_loc else second_wp.transform.location
third_wp, _ = get_waypoint_in_distance(self._reference_waypoint,
self._distance[2])
third_ground_loc = self.world.ground_projection(
third_wp.transform.location, 2)
self.third_loc_prev = third_ground_loc.location if third_ground_loc else third_wp.transform.location
# Get the debris transforms
self.first_transform = carla.Transform(self.first_loc_prev,
first_wp.transform.rotation)
self.second_transform = carla.Transform(self.second_loc_prev,
second_wp.transform.rotation)
self.third_transform = carla.Transform(self.third_loc_prev,
third_wp.transform.rotation)
# Spawn the debris
first_debris = CarlaDataProvider.request_new_actor(
'static.prop.dirtdebris01', self.first_transform, rolename='prop')
second_debris = CarlaDataProvider.request_new_actor(
'static.prop.dirtdebris01', self.second_transform, rolename='prop')
third_debris = CarlaDataProvider.request_new_actor(
'static.prop.dirtdebris01', self.third_transform, rolename='prop')
first_debris.set_transform(self.first_transform)
second_debris.set_transform(self.second_transform)
third_debris.set_transform(self.third_transform)
# Remove their physics
first_debris.set_simulate_physics(False)
second_debris.set_simulate_physics(False)
third_debris.set_simulate_physics(False)
self.other_actors.append(first_debris)
self.other_actors.append(second_debris)
self.other_actors.append(third_debris)
def _initialize_actors(self, config):
"""
Custom initialization
"""
first_vehicle_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._first_vehicle_location)
second_vehicle_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._second_vehicle_location)
second_vehicle_waypoint = second_vehicle_waypoint.get_left_lane()
first_vehicle_transform = carla.Transform(
first_vehicle_waypoint.transform.location,
first_vehicle_waypoint.transform.rotation)
second_vehicle_transform = carla.Transform(
second_vehicle_waypoint.transform.location,
second_vehicle_waypoint.transform.rotation)
first_vehicle = CarlaDataProvider.request_new_actor(
'vehicle.nissan.patrol', first_vehicle_transform)
second_vehicle = CarlaDataProvider.request_new_actor(
'vehicle.audi.tt', second_vehicle_transform)
self.other_actors.append(first_vehicle)
self.other_actors.append(second_vehicle)
self._first_actor_transform = first_vehicle_transform
self._second_actor_transform = second_vehicle_transform
def _initialize_actors(self, config):
# add actors from xml file
for actor in config.other_actors:
vehicle = CarlaActorPool.request_new_actor(actor.model,
actor.transform)
self.other_actors.append(vehicle)
vehicle.set_simulate_physics(enabled=False)
# fast vehicle, tesla
# transform visible
fast_car_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._fast_vehicle_distance)
self.fast_car_visible = carla.Transform(
carla.Location(fast_car_waypoint.transform.location.x,
fast_car_waypoint.transform.location.y,
fast_car_waypoint.transform.location.z + 1),
fast_car_waypoint.transform.rotation)
# slow vehicle, vw
# transform visible
slow_car_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._slow_vehicle_distance)
self.slow_car_visible = carla.Transform(
carla.Location(slow_car_waypoint.transform.location.x,
slow_car_waypoint.transform.location.y,
slow_car_waypoint.transform.location.z),
slow_car_waypoint.transform.rotation)
def _initialize_actors(self, config):
"""
Custom initialization
"""
first_actor_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._first_vehicle_location)
second_actor_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._second_vehicle_location)
second_actor_waypoint = second_actor_waypoint.get_left_lane()
first_actor_transform = carla.Transform(
first_actor_waypoint.transform.location,
first_actor_waypoint.transform.rotation)
if self._obstacle_type == 'vehicle':
first_actor_model = 'vehicle.nissan.micra'
else:
first_actor_transform.rotation.yaw += 90
first_actor_model = 'static.prop.streetbarrier'
second_prop_waypoint = first_actor_waypoint.next(2.0)[0]
position_yaw = second_prop_waypoint.transform.rotation.yaw + 90
offset_location = carla.Location(
0.50 * second_prop_waypoint.lane_width *
math.cos(math.radians(position_yaw)),
0.50 * second_prop_waypoint.lane_width *
math.sin(math.radians(position_yaw)))
second_prop_transform = carla.Transform(
second_prop_waypoint.transform.location + offset_location,
first_actor_transform.rotation)
second_prop_actor = CarlaDataProvider.request_new_actor(
first_actor_model, second_prop_transform)
second_prop_actor.set_simulate_physics(True)
first_actor = CarlaDataProvider.request_new_actor(
first_actor_model, first_actor_transform)
first_actor.set_simulate_physics(True)
second_actor = CarlaDataProvider.request_new_actor(
'vehicle.audi.tt', second_actor_waypoint.transform)
self.other_actors.append(first_actor)
self.other_actors.append(second_actor)
if self._obstacle_type != 'vehicle':
self.other_actors.append(second_prop_actor)
self._source_transform = second_actor_waypoint.transform
sink_waypoint = second_actor_waypoint.next(1)[0]
while not sink_waypoint.is_intersection:
sink_waypoint = sink_waypoint.next(1)[0]
self._sink_location = sink_waypoint.transform.location
self._first_actor_transform = first_actor_transform
self._second_actor_transform = second_actor_waypoint.transform
self._third_actor_transform = second_prop_transform
def _setup_scenario_trigger(self, config):
start_location = None
if config.trigger_points and config.trigger_points[0]:
start_waypoint, _ = get_waypoint_in_distance(
config.trigger_points[0], 10)
start_location = start_waypoint.location
#config.trigger_points[0].location # start location of the scenario
ego_vehicle_route = CarlaDataProvider.get_ego_vehicle_route()
if start_location:
if ego_vehicle_route:
if config.route_var_name is None: # pylint: disable=no-else-return
return conditions.InTriggerDistanceToLocationAlongRoute(
self.ego_vehicles[0], ego_vehicle_route,
start_location, 5)
else:
check_name = "WaitForBlackboardVariable: {}".format(
config.route_var_name)
return conditions.WaitForBlackboardVariable(
name=check_name,
variable_name=config.route_var_name,
variable_value=True,
var_init_value=False)
return conditions.InTimeToArrivalToLocation(
self.ego_vehicles[0], 2.0, start_location)
return None
def _calculate_transform(self):
waypoint, _ = get_waypoint_in_distance(self.trigger, self.start_dist)
lane = random.randint(0, 2)
if lane == 0:
pass
elif lane == 1:
left_lane = waypoint.get_left_lane()
if left_lane:
waypoint = left_lane
elif lane == 2:
right_lane = waypoint.get_right_lane()
if right_lane:
waypoint = right_lane
lane_width = waypoint.lane_width
position_yaw = waypoint.transform.rotation.yaw + self.offset['position']
# orientation_yaw = waypoint.transform.rotation.yaw + self.offset['orientation']
offset_location = carla.Location(
self.offset['k'] * lane_width *
math.cos(math.radians(position_yaw)), self.offset['k'] *
lane_width * math.sin(math.radians(position_yaw)))
location = waypoint.transform.location
location += offset_location
location.z += self.offset['z']
start_transform = carla.Transform(location,
waypoint.transform.rotation)
return start_transform
def _initialize_actors(self, config):
"""
Custom initialization
"""
num_actors = 0
actor_locations = []
while num_actors < self._num_actors:
actor_dict = dict()
actor_dict["speed"] = random.randint(10, 20)
actor_dict["location"] = self.generate_valid_location(
actor_locations)
actor_locations.append(actor_dict["location"])
print("actor " + str(num_actors) + " location: " +
str(actor_dict["location"]))
self.actor_list[num_actors] = actor_dict
num_actors += 1
num_actors = self._num_actors - 1
while num_actors >= 0:
vehicle_location = self.actor_list[num_actors]["location"]
# first_vehicle_waypoint, _ = get_waypoint_in_distance(self._reference_waypoint, vehicle_location)
first_vehicle_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, vehicle_location)
lane = random.randint(0, 2)
if lane == 0:
pass
elif lane == 1:
left_lane = first_vehicle_waypoint.get_left_lane()
if left_lane:
first_vehicle_waypoint = left_lane
elif lane == 2:
right_lane = first_vehicle_waypoint.get_right_lane()
if right_lane:
first_vehicle_waypoint = right_lane
# self.actor_list[num_actors]["transform"] = carla.Transform(
# carla.Location(first_vehicle_waypoint.transform.location.x,
# first_vehicle_waypoint.transform.location.y,
# first_vehicle_waypoint.transform.location.z + 1),
# first_vehicle_waypoint.transform.rotation)
other_actor_transform = carla.Transform(
carla.Location(first_vehicle_waypoint.transform.location.x,
first_vehicle_waypoint.transform.location.y,
first_vehicle_waypoint.transform.location.z +
1), first_vehicle_waypoint.transform.rotation)
self.actor_list[num_actors]["transform"] = other_actor_transform
first_vehicle_transform = carla.Transform(
carla.Location(other_actor_transform.location.x,
other_actor_transform.location.y,
other_actor_transform.location.z - 500),
other_actor_transform.rotation)
first_vehicle = CarlaActorPool.request_new_actor(
'vehicle.nissan.patrol', first_vehicle_transform)
first_vehicle.set_simulate_physics(enabled=False)
self.other_actors.append(first_vehicle)
num_actors -= 1
def _initialize_actors(self, config):
"""
Custom initialization
"""
first_actor_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._first_actor_location)
second_actor_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._second_actor_location)
first_actor_transform = carla.Transform(
carla.Location(first_actor_waypoint.transform.location.x,
first_actor_waypoint.transform.location.y,
first_actor_waypoint.transform.location.z - 500),
first_actor_waypoint.transform.rotation)
self._first_actor_transform = carla.Transform(
carla.Location(first_actor_waypoint.transform.location.x,
first_actor_waypoint.transform.location.y,
first_actor_waypoint.transform.location.z + 1),
first_actor_waypoint.transform.rotation)
yaw_1 = second_actor_waypoint.transform.rotation.yaw + 90
second_actor_transform = carla.Transform(
carla.Location(second_actor_waypoint.transform.location.x,
second_actor_waypoint.transform.location.y,
second_actor_waypoint.transform.location.z - 500),
carla.Rotation(second_actor_waypoint.transform.rotation.pitch,
yaw_1,
second_actor_waypoint.transform.rotation.roll))
self._second_actor_transform = carla.Transform(
carla.Location(second_actor_waypoint.transform.location.x,
second_actor_waypoint.transform.location.y,
second_actor_waypoint.transform.location.z + 1),
carla.Rotation(second_actor_waypoint.transform.rotation.pitch,
yaw_1,
second_actor_waypoint.transform.rotation.roll))
first_actor = CarlaActorPool.request_new_actor('vehicle.nissan.patrol',
first_actor_transform)
second_actor = CarlaActorPool.request_new_actor(
'vehicle.diamondback.century', second_actor_transform)
first_actor.set_simulate_physics(enabled=False)
second_actor.set_simulate_physics(enabled=False)
self.other_actors.append(first_actor)
self.other_actors.append(second_actor)
def _initialize_actors(self, config):
"""
Custom initialization
"""
waypoint, _ = get_waypoint_in_distance(self._reference_waypoint,
self._first_vehicle_location)
transform = waypoint.transform
transform.location.z += 0.5
first_vehicle = CarlaDataProvider.request_new_actor(
'vehicle.nissan.patrol', transform)
self.other_actors.append(first_vehicle)
def _initialize_actors(self, config):
"""
Custom initialization
"""
first_vehicle_waypoint, _ = get_waypoint_in_distance(self._reference_waypoint, self._first_vehicle_location)
self._other_actor_transform = carla.Transform(
carla.Location(first_vehicle_waypoint.transform.location.x,
first_vehicle_waypoint.transform.location.y,
first_vehicle_waypoint.transform.location.z + 1),
first_vehicle_waypoint.transform.rotation)
first_vehicle_transform = carla.Transform(
carla.Location(self._other_actor_transform.location.x,
self._other_actor_transform.location.y,
self._other_actor_transform.location.z - 500),
self._other_actor_transform.rotation)
first_vehicle = CarlaDataProvider.request_new_actor('vehicle.nissan.patrol', first_vehicle_transform)
first_vehicle.set_simulate_physics(enabled=False)
self.other_actors.append(first_vehicle)
def _calculate_transform(self):
# print("calculating transform for trigger {} at start distance {}".format(self.trigger.transform.location, self.start_dist))
waypoint, _ = get_waypoint_in_distance(self.trigger, self.start_dist)
# print("calculated waypoint location {}".format(waypoint.transform.location))
# lane = random.randint(0, 2)
# if lane == 0:
# pass
# elif lane == 1:
# left_lane = waypoint.get_left_lane()
# if left_lane:
# waypoint = left_lane
# elif lane == 2:
# right_lane = waypoint.get_right_lane()
# if right_lane:
# waypoint = right_lane
start_transform = carla.Transform(
carla.Location(waypoint.transform.location.x,
waypoint.transform.location.y,
waypoint.transform.location.z + 1),
waypoint.transform.rotation)
return start_transform
def _initialize_actors(self, config):
"""
Custom initialization
"""
first_actor_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._first_vehicle_location)
second_actor_waypoint, _ = get_waypoint_in_distance(
self._reference_waypoint, self._second_vehicle_location)
second_actor_waypoint = second_actor_waypoint.get_left_lane()
first_actor_transform = carla.Transform(
first_actor_waypoint.transform.location,
first_actor_waypoint.transform.rotation,
)
if self._obstacle_type == "vehicle":
first_actor_model = "vehicle.nissan.micra"
else:
first_actor_model = "static.prop.streetbarrier"
# first_actor_transform.rotation.yaw += 90
second_prop_waypoint = first_actor_waypoint.next(2.0)[0]
position_yaw = second_prop_waypoint.transform.rotation.yaw + 90
offset_location = carla.Location(
0.50 * second_prop_waypoint.lane_width *
math.cos(math.radians(position_yaw)),
0.50 * second_prop_waypoint.lane_width *
math.sin(math.radians(position_yaw)),
)
# second_prop_transform = carla.Transform(
# second_prop_waypoint.transform.location + offset_location,
# first_actor_transform.rotation,
# )
# second_prop_actor = CarlaActorPool.request_new_actor(
# first_actor_model, second_prop_transform)
# second_prop_actor.set_simulate_physics(True)
first_actor = CarlaActorPool.request_new_actor(first_actor_model,
first_actor_transform)
first_actor.set_simulate_physics(True)
second_actor = CarlaActorPool.request_new_actor(
"vehicle.audi.tt", second_actor_waypoint.transform)
self.other_actors.append(first_actor)
self.other_actors.append(second_actor)
# if self._obstacle_type != "vehicle":
# self.other_actors.append(second_prop_actor)
self._source_transform = second_actor_waypoint.transform
sink_waypoint = second_actor_waypoint.next(1)[0]
while not sink_waypoint.is_intersection:
sink_waypoint = sink_waypoint.next(1)[0]
self._sink_location = sink_waypoint.transform.location
self._first_actor_transform = first_actor_transform
self._second_actor_transform = second_actor_waypoint.transform
# self._third_actor_transform = second_prop_transform
offset_location = carla.Location(-35, 2.5)
pedestrian_transform = carla.Transform(
second_prop_waypoint.transform.location + offset_location,
first_actor_transform.rotation,
)
pedestrian_actor = CarlaActorPool.request_new_actor(
"walker.pedestrian.0001", pedestrian_transform)
self.other_actors.append(pedestrian_actor)
def get_route(
self,
spawn_location,
distance: float = 10.,
turning_flag=-1, # left -> -1, straight -> 0, right -> 1
resolution: float = 1.):
"""
Generate a route for the scenario.
Route is determined by class attribute turning_flag.
params:
distance: distance after the junction
resolution: distance gap between waypoint in route.
"""
waypoint_route = []
transform_route = []
location_route = []
spawn_waypoint = self.map.get_waypoint(
spawn_location,
project_to_road=True, # must set to True, center of lane
)
# start waypoint: beginning waypoint of the route,
start_waypoint = spawn_waypoint.next(3.0)[
0] # assuming that next waypoint is not in junction
# exit_waypoint: the first waypoint after leaving the junction
exit_waypoint = generate_target_waypoint(waypoint=start_waypoint,
turn=turning_flag)
# end_waypoint: end waypoint of the route
end_waypoint, _ = get_waypoint_in_distance(exit_waypoint, distance)
# list of carla.Location for route generation
raw_route = [
start_waypoint.transform.location,
exit_waypoint.transform.location,
end_waypoint.transform.location,
]
waypoint_route = interpolate_trajectory(world=self.world,
waypoints_trajectory=raw_route,
hop_resolution=resolution)
# get route of transform
for wp, road_option in waypoint_route:
transform_route.append((wp.transform, road_option))
# get route of location
for wp, road_option in waypoint_route:
location_route.append((wp.transform.location, road_option))
# ==================== visualization ====================
key_waypoints = [
start_waypoint,
exit_waypoint,
end_waypoint,
]
for wp in key_waypoints:
draw_waypoint(self.world, wp, color=(red, red))
if self.verbose:
# visualize complete route
for wp, _ in waypoint_route:
draw_waypoint(self.world, wp, color=(magenta, magenta))
return waypoint_route, location_route, transform_route
