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):
"""
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
"""
if self._randomize:
self._distance = random.randint(low=10, high=80, size=3)
self._distance = sorted(self._distance)
else:
self._distance = [14, 48, 74]
first_loc, _ = get_location_in_distance_from_wp(
self._reference_waypoint, self._distance[0])
second_loc, _ = get_location_in_distance_from_wp(
self._reference_waypoint, self._distance[1])
third_loc, _ = get_location_in_distance_from_wp(
self._reference_waypoint, self._distance[2])
self.loc_list.extend([first_loc, second_loc, third_loc])
self._dist_prop = [x - 2 for x in self._distance]
self.first_loc_prev, _ = get_location_in_distance_from_wp(
self._reference_waypoint, self._dist_prop[0])
self.sec_loc_prev, _ = get_location_in_distance_from_wp(
self._reference_waypoint, self._dist_prop[1])
self.third_loc_prev, _ = get_location_in_distance_from_wp(
self._reference_waypoint, self._dist_prop[2])
self.first_transform = carla.Transform(self.first_loc_prev)
self.sec_transform = carla.Transform(self.sec_loc_prev)
self.third_transform = carla.Transform(self.third_loc_prev)
self.first_transform = carla.Transform(
carla.Location(self.first_loc_prev.x, self.first_loc_prev.y,
self.first_loc_prev.z))
self.sec_transform = carla.Transform(
carla.Location(self.sec_loc_prev.x, self.sec_loc_prev.y,
self.sec_loc_prev.z))
self.third_transform = carla.Transform(
carla.Location(self.third_loc_prev.x, self.third_loc_prev.y,
self.third_loc_prev.z))
first_debris = CarlaDataProvider.request_new_actor(
'static.prop.dirtdebris01', self.first_transform, 'prop')
second_debris = CarlaDataProvider.request_new_actor(
'static.prop.dirtdebris01', self.sec_transform, 'prop')
third_debris = CarlaDataProvider.request_new_actor(
'static.prop.dirtdebris01', self.third_transform, 'prop')
first_debris.set_transform(self.first_transform)
second_debris.set_transform(self.sec_transform)
third_debris.set_transform(self.third_transform)
self.obj.extend([first_debris, second_debris, third_debris])
for debris in self.obj:
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_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 test_all_xosc(self):
"""
Load all examples OpenSCENARIO files
"""
all_test_files = glob.glob('**/srunner/examples/*.xosc',
recursive=True)
for filename in all_test_files:
client = carla.Client()
config = OpenScenarioConfiguration(filename, client, {})
self.assertTrue(config is not None)
CarlaDataProvider.set_client(client)
ego_vehicles = []
for vehicle in config.ego_vehicles:
ego_vehicles.append(
CarlaDataProvider.request_new_actor(
vehicle.model,
vehicle.transform,
vehicle.rolename,
color=vehicle.color,
actor_category=vehicle.category))
scenario = OpenScenario(world=client.get_world(),
ego_vehicles=ego_vehicles,
config=config,
config_file=filename,
timeout=100000)
self.assertTrue(scenario is not None)
CarlaDataProvider.cleanup()
def _spawn_blocker(self, transform, orientation_yaw):
"""
Spawn the blocker prop that blocks the vision from the egovehicle of the jaywalker
:return:
"""
# static object transform
shift = 0.9
x_ego = self._reference_waypoint.transform.location.x
y_ego = self._reference_waypoint.transform.location.y
x_cycle = transform.location.x
y_cycle = transform.location.y
x_static = x_ego + shift * (x_cycle - x_ego)
y_static = y_ego + shift * (y_cycle - y_ego)
spawn_point_wp = self.ego_vehicles[0].get_world().get_map(
).get_waypoint(transform.location)
self.transform2 = carla.Transform(
carla.Location(x_static, y_static,
spawn_point_wp.transform.location.z + 0.3),
carla.Rotation(yaw=orientation_yaw + 180))
static = CarlaDataProvider.request_new_actor(
'static.prop.vendingmachine', self.transform2)
static.set_simulate_physics(enabled=False)
return static
def _initialize_actors(self, config):
# add actors from xml file
for actor in config.other_actors:
vehicle = CarlaDataProvider.request_new_actor(
actor.model, actor.transform)
self.other_actors.append(vehicle)
vehicle.set_simulate_physics(enabled=True)
def _initialize_actors(self, config):
# add actors from xml file
for actor in config.other_actors:
vehicle = CarlaDataProvider.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 _prepare_ego_vehicles(self, ego_vehicles, wait_for_ego_vehicles=False):
"""
Spawn or update the ego vehicles
"""
if not wait_for_ego_vehicles:
for vehicle in ego_vehicles:
self.ego_vehicles.append(CarlaDataProvider.request_new_actor(vehicle.model,
vehicle.transform,
vehicle.rolename,
color=vehicle.color,
vehicle_category=vehicle.category))
else:
ego_vehicle_missing = True
while ego_vehicle_missing:
self.ego_vehicles = []
ego_vehicle_missing = False
for ego_vehicle in ego_vehicles:
ego_vehicle_found = False
carla_vehicles = CarlaDataProvider.get_world().get_actors().filter('vehicle.*')
for carla_vehicle in carla_vehicles:
if carla_vehicle.attributes['role_name'] == ego_vehicle.rolename:
ego_vehicle_found = True
self.ego_vehicles.append(carla_vehicle)
break
if not ego_vehicle_found:
ego_vehicle_missing = True
break
for i, _ in enumerate(self.ego_vehicles):
self.ego_vehicles[i].set_transform(ego_vehicles[i].transform)
# sync state
CarlaDataProvider.get_world().tick()
def _spawn_adversary(self, transform, orientation_yaw):
self._time_to_reach *= self._num_lane_changes
if self._adversary_type is False:
self._walker_yaw = orientation_yaw
# self._other_actor_target_velocity = 3 + (0.4 * self._num_lane_changes)
walker = CarlaDataProvider.request_new_actor('walker.*', transform)
adversary = walker
else:
# self._other_actor_target_velocity = self._other_actor_target_velocity * self._num_lane_changes
first_vehicle = CarlaDataProvider.request_new_actor(
'vehicle.diamondback.century', transform)
first_vehicle.set_simulate_physics(enabled=False)
adversary = first_vehicle
return adversary
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 = CarlaDataProvider.request_new_actor(
'vehicle.nissan.patrol', first_actor_transform)
second_actor = CarlaDataProvider.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 _update_ego_vehicle(self):
"""
Set/Update the start position of the ego_vehicle
"""
# move ego to correct position
elevate_transform = self.route[0][0]
elevate_transform.location.z += 0.5
ego_vehicle = CarlaDataProvider.request_new_actor(
'vehicle.lincoln.mkz2017', elevate_transform, rolename='hero')
return ego_vehicle
def _initialize_actors(self, config):
"""
Custom initialization
"""
self._other_actor_transform = config.other_actors[0].transform
first_vehicle_transform = carla.Transform(
carla.Location(config.other_actors[0].transform.location.x,
config.other_actors[0].transform.location.y,
config.other_actors[0].transform.location.z),
config.other_actors[0].transform.rotation)
first_vehicle = CarlaDataProvider.request_new_actor(
config.other_actors[0].model, first_vehicle_transform)
self.other_actors.append(first_vehicle)
def _spawn_ego_car(self, start_transform):
"""
Spawn or update all scenario actors according to
a certain start position.
"""
# If ego_vehicle already exists, just update location
# Otherwise spawn ego vehicle
self._ego_actor = CarlaDataProvider.request_new_actor(
self._vehicle_model, start_transform)
CarlaDataProvider.set_ego_vehicle_route(
convert_transform_to_location(self._route))
logging.debug("Created Ego Vehicle")
def _create_construction_setup(self, start_transform, lane_width):
"""
Create Construction Setup
"""
_initial_offset = {'cones': {'yaw': 180, 'k': lane_width / 2.0},
'warning_sign': {'yaw': 180, 'k': 5, 'z': 0},
'debris': {'yaw': 0, 'k': 2, 'z': 1}}
_prop_names = {'warning_sign': 'static.prop.trafficwarning',
'debris': 'static.prop.dirtdebris02'}
_perp_angle = 90
_setup = {'lengths': [0, 6, 3], 'offsets': [0, 2, 1]}
_z_increment = 0.1
############################# Traffic Warning and Debris ##############
for key, value in _initial_offset.items():
if key == 'cones':
continue
transform = carla.Transform(
start_transform.location,
start_transform.rotation)
transform.rotation.yaw += value['yaw']
transform.location += value['k'] * \
transform.rotation.get_forward_vector()
transform.location.z += value['z']
transform.rotation.yaw += _perp_angle
static = CarlaDataProvider.request_new_actor(
_prop_names[key], transform)
static.set_simulate_physics(True)
self.other_actors.append(static)
############################# Cones ###################################
side_transform = carla.Transform(
start_transform.location,
start_transform.rotation)
side_transform.rotation.yaw += _perp_angle
side_transform.location -= _initial_offset['cones']['k'] * \
side_transform.rotation.get_forward_vector()
side_transform.rotation.yaw += _initial_offset['cones']['yaw']
for i in range(len(_setup['lengths'])):
self.create_cones_side(
side_transform,
forward_vector=side_transform.rotation.get_forward_vector(),
z_inc=_z_increment,
cone_length=_setup['lengths'][i],
cone_offset=_setup['offsets'][i])
side_transform.location += side_transform.get_forward_vector() * \
_setup['lengths'][i] * _setup['offsets'][i]
side_transform.rotation.yaw += _perp_angle
def _initialize_actors(self, config):
"""
Custom initialization
"""
# Get the waypoint right after the junction
waypoint = generate_target_waypoint_in_route(self._reference_waypoint, self._ego_route)
# Move a certain distance to the front
start_distance = 8
waypoint = waypoint.next(start_distance)[0]
# Get the last driving lane to the right
waypoint, self._num_lane_changes = get_right_driving_lane(waypoint)
# And for synchrony purposes, move to the front a bit
added_dist = self._num_lane_changes
while True:
# Try to spawn the actor
try:
self._other_actor_transform = get_opponent_transform(added_dist, waypoint, self._trigger_location)
# addition
self._other_actor_transform.location.x += self.customized_data['dx']
self._other_actor_transform.location.y += self.customized_data['dy']
self._other_actor_transform.rotation.yaw += self.customized_data['dyaw']
first_vehicle = CarlaDataProvider.request_new_actor(
self.customized_data['actor_type'], self._other_actor_transform)
first_vehicle.set_simulate_physics(enabled=False)
break
# Move the spawning point a bit and try again
except RuntimeError as r:
# In the case there is an object just move a little bit and retry
print(" Base transform is blocking objects ", self._other_actor_transform)
added_dist += 0.5
self._spawn_attempted += 1
if self._spawn_attempted >= self._number_of_attempts:
raise r
# Set the transform to -500 z after we are able to spawn it
actor_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.set_transform(actor_transform)
first_vehicle.set_simulate_physics(enabled=False)
self.other_actors.append(first_vehicle)
def _update_ego_vehicle(self):
"""
Set/Update the start position of the ego_vehicle
"""
# move ego to correct position
elevate_transform = self.route[0][0]
elevate_transform.location.z += 0.5
ego_vehicle = CarlaDataProvider.request_new_actor(
'vehicle.lincoln.mkz2017', elevate_transform, rolename='hero')
# self.tm.vehicle_percentage_speed_difference(ego_vehicle, -100)
# self.tm.global_percentage_speed_difference(-100)
return ego_vehicle
def _initialize_actors(self, config):
"""
Custom initialization
"""
self._other_actor_transform = config.other_actors[0].transform
first_vehicle_transform = carla.Transform(
carla.Location(config.other_actors[0].transform.location.x,
config.other_actors[0].transform.location.y,
config.other_actors[0].transform.location.z - 500),
config.other_actors[0].transform.rotation)
first_vehicle = CarlaDataProvider.request_new_actor(config.other_actors[0].model, self._other_actor_transform)
first_vehicle.set_transform(first_vehicle_transform)
first_vehicle.set_simulate_physics(enabled=False)
self.other_actors.append(first_vehicle)
def _update_ego_vehicle(self):
"""
Set/Update the start position of the ego_vehicle
"""
# move ego to correct position
elevate_transform = self.route[0][0]
elevate_transform.location.z += 0.5
ego_vehicle = CarlaDataProvider.request_new_actor(
'vehicle.lincoln.mkz2017', elevate_transform, rolename='hero')
# change physics
physics_control = ego_vehicle.get_physics_control()
physics_control.wheels = self.config.wheels_physics
ego_vehicle.apply_physics_control(physics_control)
return ego_vehicle
def _update_ego_vehicle(self):
"""
Set/Update the start position of the ego_vehicle
"""
# move ego to correct position
elevate_transform = self.route[0][0]
elevate_transform.location.z += 0.5
ego_vehicle = CarlaDataProvider.request_new_actor(
'vehicle.lincoln.mkz2017', elevate_transform, rolename='hero')
spectator = CarlaDataProvider.get_world().get_spectator()
ego_trans = ego_vehicle.get_transform()
spectator.set_transform(
carla.Transform(ego_trans.location + carla.Location(z=50),
carla.Rotation(pitch=-90)))
return ego_vehicle
def update(self):
if not self.distance_gap:
self.distance_gap = self._threshold
new_status = py_trees.common.Status.RUNNING
# self._threshold = 20
if self._actor_limit > 0:
world_actors = self._world.get_actors()
vehicle_list = world_actors.filter('vehicle.*')
vehicles = []
for veh in vehicle_list:
if veh.attributes['role_name'] == 'scenario': # todo fix role_name if set by args
vehicles.append(veh)
spawn_point_blocked = False
if (self._last_blocking_actor and
self._spawn_point.location.distance(self._last_blocking_actor.get_location()) < self.distance_gap):
spawn_point_blocked = True
if not spawn_point_blocked:
# for actor in world_actors:
for actor in vehicles:
if self._spawn_point.location.distance(actor.get_location()) < self.distance_gap:
spawn_point_blocked = True
self._last_blocking_actor = actor
break
if not spawn_point_blocked:
try:
new_actor = CarlaDataProvider.request_new_actor(
np.random.choice(self._actor_types), self._spawn_point)
self._actor_limit -= 1
self._queue.put(new_actor)
set_vehicle_speed(new_actor, self.init_speed / 3.6)
# update distance gap after generating a new actor
if self.randomize:
sigma = 0.1
self.distance_gap = random.uniform(self._threshold * (1-sigma), self._threshold * (1+sigma))
except: # pylint: disable=bare-except
print("ActorSource unable to spawn actor")
return new_status
def _prepare_ego_vehicles(self, ego_vehicles):
"""
Spawn or update the ego vehicles
"""
if not self._args.waitForEgo:
for vehicle in ego_vehicles:
self.ego_vehicles.append(
CarlaDataProvider.request_new_actor(
vehicle.model,
vehicle.transform,
vehicle.rolename,
color=vehicle.color,
actor_category=vehicle.category))
else:
ego_vehicle_missing = True
while ego_vehicle_missing:
self.ego_vehicles = []
ego_vehicle_missing = False
for ego_vehicle in ego_vehicles:
ego_vehicle_found = False
carla_vehicles = CarlaDataProvider.get_world().get_actors(
).filter('vehicle.*')
for carla_vehicle in carla_vehicles:
if carla_vehicle.attributes[
'role_name'] == ego_vehicle.rolename:
ego_vehicle_found = True
self.ego_vehicles.append(carla_vehicle)
break
if not ego_vehicle_found:
ego_vehicle_missing = True
break
for i, _ in enumerate(self.ego_vehicles):
self.ego_vehicles[i].set_transform(ego_vehicles[i].transform)
CarlaDataProvider.register_actor(self.ego_vehicles[i])
# self.traffic_manager.vehicle_percentage_speed_difference(-70)
# sync state
if CarlaDataProvider.is_sync_mode():
self.world.tick()
else:
self.world.wait_for_tick()
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 _initialize_actors(self, config):
"""
Custom initialization
"""
# Get the waypoint right after the junction
waypoint = self._get_target_waypoint()
move_dist = self._start_distance
while self._number_of_attempts > 0:
# Move to the front
waypoint = waypoint.next(move_dist)[0]
self._collision_wp = waypoint
# Move to the right
sidewalk_waypoint = waypoint
while sidewalk_waypoint.lane_type != carla.LaneType.Sidewalk:
right_wp = sidewalk_waypoint.get_right_lane()
if right_wp is None:
break # No more right lanes
sidewalk_waypoint = right_wp
# Get the adversary transform and spawn it
self._adversary_transform = get_sidewalk_transform(sidewalk_waypoint)
adversary = CarlaDataProvider.request_new_actor('vehicle.diamondback.century', self._adversary_transform)
if adversary is None:
self._number_of_attempts -= 1
move_dist = self._retry_dist
self._spawn_dist += self._retry_dist
continue
# Both actors where summoned, end
break
if self._number_of_attempts == 0:
raise Exception("Couldn't find viable position for the adversary actor")
if isinstance(adversary, carla.Vehicle):
adversary.apply_control(carla.VehicleControl(hand_brake=True))
self.other_actors.append(adversary)
def _initialize_actors(self, config):
# direction of lane, on which other_actor is driving before lane change
if 'LEFT' in self._config.name.upper():
self._direction = 'left'
if 'RIGHT' in self._config.name.upper():
self._direction = 'right'
# add actors from xml file
for actor in config.other_actors:
vehicle = CarlaDataProvider.request_new_actor(
actor.model, actor.transform)
self.other_actors.append(vehicle)
vehicle.set_simulate_physics(enabled=False)
# transform visible
other_actor_transform = self.other_actors[0].get_transform()
self._transform_visible = carla.Transform(
carla.Location(other_actor_transform.location.x,
other_actor_transform.location.y,
other_actor_transform.location.z + 105),
other_actor_transform.rotation)
def _initialize_actors(self, config):
"""
Custom initialization
"""
# Get the waypoint left after the junction
waypoint = generate_target_waypoint(self._reference_waypoint, 1)
while True:
# Try to spawn the actor
try:
self._other_actor_transform = waypoint.transform
first_vehicle = CarlaDataProvider.request_new_actor(
'vehicle.*', self._other_actor_transform)
first_vehicle.set_simulate_physics(enabled=False)
break
# Move the spawning point a bit and try again
except RuntimeError as r:
# In the case there is an object just move a little bit and retry
waypoint = waypoint.next(1)[0]
self._spawn_attempted += 1
if self._spawn_attempted >= self._number_of_attempts:
raise r
# Set the transform to -500 z after we are able to spawn it
actor_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.set_transform(actor_transform)
first_vehicle.set_simulate_physics(enabled=False)
self.other_actors.append(first_vehicle)
def _initialize_actors(self, config):
"""
Custom initialization
"""
_start_distance = 40
lane_width = self._reference_waypoint.lane_width
location, _ = get_location_in_distance_from_wp(
self._reference_waypoint, _start_distance)
waypoint = self._wmap.get_waypoint(location)
offset = {"orientation": 270, "position": 90, "z": 0.4, "k": 0.2}
position_yaw = waypoint.transform.rotation.yaw + offset['position']
orientation_yaw = waypoint.transform.rotation.yaw + offset[
'orientation']
offset_location = carla.Location(
offset['k'] * lane_width * math.cos(math.radians(position_yaw)),
offset['k'] * lane_width * math.sin(math.radians(position_yaw)))
location += offset_location
location.z += offset['z']
self.transform = carla.Transform(location,
carla.Rotation(yaw=orientation_yaw))
static = CarlaDataProvider.request_new_actor('static.prop.container',
self.transform)
static.set_simulate_physics(True)
self.other_actors.append(static)
def create_cones_side(
self,
start_transform,
forward_vector,
z_inc=0,
cone_length=0,
cone_offset=0):
"""
Creates One Side of the Cones
"""
_dist = 0
while _dist < (cone_length * cone_offset):
# Move forward
_dist += cone_offset
forward_dist = carla.Vector3D(0, 0, 0) + forward_vector * _dist
location = start_transform.location + forward_dist
location.z += z_inc
transform = carla.Transform(location, start_transform.rotation)
cone = CarlaDataProvider.request_new_actor(
'static.prop.constructioncone', transform)
cone.set_simulate_physics(True)
self.other_actors.append(cone)
def _request_actor(self,
actor_category,
actor_model,
waypoint_transform,
simulation_enabled=False,
color=None,
bounds=None,
is_waypoint_follower=None,
center_transform=None):
def bound_xy(generated_transform, bounds):
if bounds:
x_min, x_max, y_min, y_max = bounds
g_x = generated_transform.location.x
g_y = generated_transform.location.y
if center_transform:
c_x = center_transform.location.x
c_y = center_transform.location.y
x_min += c_x
x_max += c_x
y_min += c_y
y_max += c_y
generated_transform.location.x = np.max([g_x, x_min])
generated_transform.location.x = np.min([g_x, x_max])
generated_transform.location.y = np.max([g_y, y_min])
generated_transform.location.y = np.min([g_y, y_max])
# print('bounds', x_min, x_max, y_min, y_max, g_x, g_y, center_transform)
# If we fail too many times, this will break and the session will be assigned the lowest default score. We do this to disencourage samples that result in invalid locations
# Number of attempts made so far
status = 'success'
is_success = False
generated_transform = copy_transform(waypoint_transform)
if actor_category != 'vehicle':
g_x = generated_transform.location.x
g_y = generated_transform.location.y
g_yaw = generated_transform.rotation.yaw
for i in range(self._number_of_attempts):
for j in range(2):
try:
added_dist = i * 0.5
cur_x = g_x + np.random.uniform(0, added_dist)
cur_y = g_y + np.random.uniform(0, added_dist)
cur_t = create_transform(cur_x, cur_y, 0, 0, g_yaw, 0)
generated_transform.location.y += np.random.uniform(
0, 1)
bound_xy(generated_transform, bounds)
actor_object = CarlaDataProvider.request_new_actor(
model=actor_model,
spawn_point=cur_t,
color=color,
actor_category=actor_category)
is_success = True
break
except (RuntimeError, AttributeError) as r:
status = 'fail_1_' + str(i)
if is_success:
break
if actor_category == 'vehicle' or status == 'fail_1_' + str(
self._number_of_attempts):
for i in range(self._number_of_attempts):
try:
added_dist = i * 0.5
waypoint = self._wmap.get_waypoint(
waypoint_transform.location,
project_to_road=True,
lane_type=carla.LaneType.Any)
generated_transform = get_generated_transform(
added_dist, waypoint)
# if actor_category == 'vehicle' and is_waypoint_follower:
generated_transform.rotation.yaw = waypoint_transform.rotation.yaw
bound_xy(generated_transform, bounds)
actor_object = CarlaDataProvider.request_new_actor(
model=actor_model,
spawn_point=generated_transform,
color=color,
actor_category=actor_category)
is_success = True
break
except (RuntimeError, AttributeError) as r:
status = 'fail_2_' + str(i)
if is_success:
actor_object.set_simulate_physics(enabled=simulation_enabled)
else:
actor_object = None
generated_transform = None
status = 'fail_all'
if status != 'success' and is_success:
print('{} {} {} ({:.2f},{:.2f},{:.2f})->({:.2f},{:.2f},{:.2f})'.
format(status, actor_model, is_waypoint_follower,
waypoint_transform.location.x,
waypoint_transform.location.y,
waypoint_transform.rotation.yaw,
generated_transform.location.x,
generated_transform.location.y,
waypoint_transform.rotation.yaw))
else:
print(status, actor_category, actor_model, is_waypoint_follower)
return actor_object, generated_transform
