def main():
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(10.0)
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
#xodr_path = "Crossing8Course.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 50.0 # in meters
wall_height = 1.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data,
carla.OpendriveGenerationParameters(vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
spectator = world.get_spectator()
blueprint = world.get_blueprint_library().filter('vehicle.*model3*')[0]
waypoints = world.get_map().generate_waypoints(2.0)
targetLane = -3
waypoint = waypoints[0]
waypoint = change_lane(waypoint, targetLane - waypoint.lane_id)
location = waypoint.transform.location + carla.Vector3D(0, 0, 1.5)
rotation = waypoint.transform.rotation
print(location)
print(rotation)
vehicle = world.spawn_actor(blueprint, carla.Transform(location, rotation))
actor_list.append(
vehicle) #Add actor to list in order to destroy when program completes
vehicle.set_simulate_physics(False)
physics_control = vehicle.get_physics_control()
max_steer = physics_control.wheels[0].max_steer_angle
rear_axle_center = (physics_control.wheels[2].position +
physics_control.wheels[3].position) / 200
offset = rear_axle_center - vehicle.get_location()
wheelbase = np.linalg.norm([offset.x, offset.y, offset.z])
vehicle.set_simulate_physics(True)
locations = first_lap(world, vehicle, targetLane, max_steer, wheelbase,
spectator)
print(locations)
def main():
global world
global vehicle_list
# global lock
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(10.0)
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
#xodr_path = "Crossing8Course.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 10.0 # in meters #Changed from 50.0
wall_height = 5.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data, carla.OpendriveGenerationParameters(
vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
# world = client.get_world()
settings = world.get_settings()
settings.synchronous_mode = True # Enables synchronous mode
settings.fixed_delta_seconds = 0.1 # simulation time between two frames
world.apply_settings(settings)
tick_rate = 10.0 # number of ticks per second, assuming tick() runs in zero time
transform = waypoints = world.get_map().generate_waypoints(10.0)
#Change targetLane and waypoint index depending on where you want the vehicle to spawn
targetLane = -3
waypoint = waypoints[500]
waypoint = change_lane(waypoint, targetLane - waypoint.lane_id)
location = waypoint.transform.location + carla.Vector3D(0, 0, 0.5)
rotation = waypoint.transform.rotation
transform = carla.Transform(location, rotation)
vehicle_1 = Autonomous_Vehicle(['lidar', 'collision', 'camera'], transform, Disparity_Extender(), Pure_Pursuit_Controller())
vehicle_list.append(vehicle_1)
world.on_tick(lambda world_snapshot: vehicle_1.control_loop())
while True:
time.sleep(1/tick_rate)
world.tick()
def main():
global target_cartesian
global lock
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(10.0)
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
#xodr_path = "Crossing8Course.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 10.0 # in meters #Changed from 50.0
wall_height = 5.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data,
carla.OpendriveGenerationParameters(vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
spectator = world.get_spectator()
vehicle, camera, controller = spawn_actor(world)
if (target_cartesian is not None): #wait until first Lidar scan
while True:
print(target_cartesian)
time.sleep(1)
#When all actors have been spawned
vehicle_transform = vehicle.get_transform()
speed = math.sqrt(vehicle.get_velocity().x**2 +
vehicle.get_velocity().y**2)
throttle = controller.throttle_control(speed)
#print("target polar: " + str(target_cartesian))
steer = controller.cartesian_steering_control(target_cartesian)
#steer = 0
print("steer: " + str(steer))
control = carla.VehicleControl(throttle, steer)
spectator.set_transform(camera.get_transform())
vehicle.apply_control(control)
def main():
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(10.0)
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
#xodr_path = "Crossing8Course.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 10.0 # in meters #Changed from 50.0
wall_height = 5.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data,
carla.OpendriveGenerationParameters(vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
settings = world.get_settings()
settings.synchronous_mode = True # Enables synchronous mode
settings.fixed_delta_seconds = None # Set a variable time
world.apply_settings(settings)
world_snapshot = world.wait_for_tick()
world.on_tick(lambda world_snapshot: do_something(world_snapshot))
spectator = world.get_spectator()
spawn_actor(world)
while True:
world.tick()
#When all actors have been spawned
if (len(actor_list) >= 4):
control_vehicle(actor_list[0])
camera = actor_list[1]
spectator.set_transform(camera.get_transform())
world.wait_for_tick()
def main():
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(10.0)
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
#xodr_path = "Crossing8Course.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 10.0 # in meters #Changed from 50.0
wall_height = 5.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data,
carla.OpendriveGenerationParameters(vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
spectator = world.get_spectator()
spawn_actor(world)
while True:
print(actor_list)
#When all actors have been spawned
if (len(actor_list) >= 4):
print("true")
control_vehicle(actor_list[0])
camera = actor_list[1]
spectator.set_transform(camera.get_transform())
timestamp = world.wait_for_tick()
delta_seconds = timestamp.delta_seconds
time.sleep(delta_seconds)
print("update")
def load_opendrive_world(client):
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 10.0 # in meters #Changed from 50.0
wall_height = 5.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data, carla.OpendriveGenerationParameters(
vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
settings = world.get_settings()
settings.synchronous_mode = True # Enables synchronous mode
settings.fixed_delta_seconds = 0.05 # simulation time between two frames
world.apply_settings(settings)
return world
def main():
argparser = argparse.ArgumentParser(description=__doc__)
argparser.add_argument(
'--host',
metavar='H',
default='localhost',
help='IP of the host CARLA Simulator (default: localhost)')
argparser.add_argument('-p',
'--port',
metavar='P',
default=2000,
type=int,
help='TCP port of CARLA Simulator (default: 2000)')
argparser.add_argument('-d',
'--default',
action='store_true',
help='set default settings')
argparser.add_argument(
'-m', '--map', help='load a new map, use --list to see available maps')
argparser.add_argument('-r',
'--reload-map',
action='store_true',
help='reload current map')
argparser.add_argument(
'--delta-seconds',
metavar='S',
type=float,
help='set fixed delta seconds, zero for variable frame rate')
argparser.add_argument(
'--fps',
metavar='N',
type=float,
help='set fixed FPS, zero for variable FPS (similar to --delta-seconds)'
)
argparser.add_argument('--rendering',
action='store_true',
help='enable rendering')
argparser.add_argument('--no-rendering',
action='store_true',
help='disable rendering')
argparser.add_argument('--no-sync',
action='store_true',
help='disable synchronous mode')
argparser.add_argument(
'--weather',
help='set weather preset, use --list to see available presets')
argparser.add_argument('-i',
'--inspect',
action='store_true',
help='inspect simulation')
argparser.add_argument('-l',
'--list',
action='store_true',
help='list available options')
argparser.add_argument(
'-b',
'--list-blueprints',
metavar='FILTER',
help=
'list available blueprints matching FILTER (use \'*\' to list them all)'
)
argparser.add_argument(
'-x',
'--xodr-path',
metavar='XODR_FILE_PATH',
help=
'load a new map with a minimum physical road representation of the provided OpenDRIVE'
)
if len(sys.argv) < 2:
argparser.print_help()
return
args = argparser.parse_args()
client = carla.Client(args.host, args.port, worker_threads=1)
client.set_timeout(10.0)
print(client.get_available_maps())
if args.map is not None:
print('load map %r.' % args.map)
world = client.load_world(args.map)
elif args.reload_map:
print('reload map.')
world = client.reload_world()
elif args.xodr_path is not None:
if os.path.exists(args.xodr_path):
with open(args.xodr_path) as od_file:
try:
data = od_file.read()
except OSError:
print('file could not be readed.')
sys.exit()
print('load opendrive map %r.' % os.path.basename(args.xodr_path))
vertex_distance = 2.0 # in meters
max_road_length = 500.0 # in meters
wall_height = 1.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data,
carla.OpendriveGenerationParameters(
vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
else:
print('file not found.')
else:
world = client.get_world()
settings = world.get_settings()
if args.no_rendering:
print('disable rendering.')
settings.no_rendering_mode = True
elif args.rendering:
print('enable rendering.')
settings.no_rendering_mode = False
if args.no_sync:
print('disable synchronous mode.')
settings.synchronous_mode = False
if args.delta_seconds is not None:
settings.fixed_delta_seconds = args.delta_seconds
elif args.fps is not None:
settings.fixed_delta_seconds = (1.0 /
args.fps) if args.fps > 0.0 else 0.0
if args.delta_seconds is not None or args.fps is not None:
if settings.fixed_delta_seconds > 0.0:
print('set fixed frame rate %.2f milliseconds (%d FPS)' %
(1000.0 * settings.fixed_delta_seconds,
1.0 / settings.fixed_delta_seconds))
else:
print('set variable frame rate.')
settings.fixed_delta_seconds = None
world.apply_settings(settings)
if args.weather is not None:
if not hasattr(carla.WeatherParameters, args.weather):
print('ERROR: weather preset %r not found.' % args.weather)
else:
print('set weather preset %r.' % args.weather)
world.set_weather(getattr(carla.WeatherParameters, args.weather))
if args.inspect:
inspect(args, client)
if args.list:
list_options(client)
if args.list_blueprints:
list_blueprints(world, args.list_blueprints)
def main():
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(10.0)
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
#xodr_path = "Crossing8Course.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 50.0 # in meters
wall_height = 5.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data,
carla.OpendriveGenerationParameters(vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
spectator = world.get_spectator()
blueprint = world.get_blueprint_library().filter('vehicle.*model3*')[0]
waypoints = world.get_map().generate_waypoints(2.0)
targetLane = -3
waypoint = waypoints[0]
waypoint = change_lane(waypoint, targetLane - waypoint.lane_id)
location = waypoint.transform.location + carla.Vector3D(0, 0, 1.5)
rotation = waypoint.transform.rotation
print(location)
print(rotation)
vehicle = world.spawn_actor(blueprint, carla.Transform(location, rotation))
actor_list.append(
vehicle) #Add actor to list in order to destroy when program completes
vehicle.set_simulate_physics(False)
physics_control = vehicle.get_physics_control()
max_steer = physics_control.wheels[0].max_steer_angle
rear_axle_center = (physics_control.wheels[2].position +
physics_control.wheels[3].position) / 200
offset = rear_axle_center - vehicle.get_location()
wheelbase = np.linalg.norm([offset.x, offset.y, offset.z])
vehicle.set_simulate_physics(True)
transform = carla.Transform(carla.Location(x=0.8, z=1.7))
#Configure collision sensor
collision_bp = world.get_blueprint_library().find('sensor.other.collision')
collision_sensor = world.spawn_actor(collision_bp,
transform,
attach_to=vehicle)
actor_list.append(collision_sensor)
#configure LIDAR sensor to only output 2d
# Find the blueprint of the sensor.
lidar_bp = world.get_blueprint_library().find('sensor.lidar.ray_cast')
# Set the time in seconds between sensor captures
lidar_bp.set_attribute('sensor_tick', '0.1')
lidar_bp.set_attribute('channels', '1')
lidar_bp.set_attribute('upper_fov', '0')
#lidar_bp.set_attribute('lower_fov', '0')
lidar_bp.set_attribute('range', '10') #10 is default
lidar_bp.set_attribute('points_per_second', '500')
#With 2 channels, and 100 points per second, here are 250 points per scan
lidar_sensor = world.spawn_actor(lidar_bp, transform, attach_to=vehicle)
actor_list.append(lidar_sensor)
lidar_sensor.listen(lambda data: save_lidar_image(data, world, vehicle))
throttle = 0.85
control = carla.VehicleControl(throttle, 0)
vehicle.apply_control(control)
while True:
spectator.set_transform(get_transform(vehicle.get_location(), 145))
def main():
global first_quarter_time, second_quarter_time, third_quarter_time, fourth_quarter_time
global actor_list
##Modifiable Variables
targetLane = -3
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(10.0)
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
#xodr_path = "Crossing8Course.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 50.0 # in meters
wall_height = 1.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data,
carla.OpendriveGenerationParameters(vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
spectator = world.get_spectator()
map = world.get_map()
waypoint_list = map.generate_waypoints(40)
print("Length: " + str(len(waypoint_list)))
#Take only the waypoints from the targetLane
waypoints = single_lane(waypoint_list, targetLane)
#Remove all unneccesary waypoints along the straights
curvy_waypoints = get_curvy_waypoints(waypoints)
modify_waypoints(curvy_waypoints)
#Save graph of plotted points as bezier.png
x = [-p.transform.location.x for p in curvy_waypoints]
y = [p.transform.location.y for p in curvy_waypoints]
plt.plot(x, y, marker='o')
i = 5 #initial point
#Set spawning location as initial waypoint
spawnpoint = curvy_waypoints[i]
blueprint = world.get_blueprint_library().filter('vehicle.*model3*')[0]
location = spawnpoint.transform.location + carla.Vector3D(0, 0, 1.5)
rotation = spawnpoint.transform.rotation
print("location: " + str(location))
print("rotation: " + str(rotation))
vehicle = world.spawn_actor(blueprint, carla.Transform(location, rotation))
actor_list.append(vehicle)
print("spawn location: " + str(vehicle.get_transform().location))
print("spawn rotation: " + str(vehicle.get_transform().rotation))
print(world.get_actor(vehicle.id).get_transform())
print("SPAWNED!")
#plt.plot(-vehicle.get_location().x, vehicle.get_location().y, marker = 'o', color = 'r')
num = 8
plt.axis([-1400, 400, -750, 50])
plt.savefig("new_bezier.png")
#Vehicle properties setup
physics_control = vehicle.get_physics_control()
max_steer = physics_control.wheels[0].max_steer_angle
rear_axle_center = (physics_control.wheels[2].position +
physics_control.wheels[3].position) / 200
offset = rear_axle_center - vehicle.get_location()
wheelbase = np.linalg.norm([offset.x, offset.y, offset.z])
vehicle.set_simulate_physics(True)
#Add spectator camera to get the view to move with the car
camera_bp = world.get_blueprint_library().find('sensor.camera.rgb')
camera_transform = carla.Transform(carla.Location(x=-10, z=10),
carla.Rotation(-30, 0, 0))
camera = world.spawn_actor(camera_bp, camera_transform, attach_to=vehicle)
actor_list.append(camera)
transform = carla.Transform(carla.Location(x=0.8, z=1.7))
##INSERT MODIFYING WAYPOINTS HERE
array = []
for p in curvy_waypoints:
x = '{0:.10f}'.format(float(p.transform.location.x))
y = '{0:.10f}'.format(float(p.transform.location.y))
array.append([x, y])
np.savetxt("waypoints.csv", array)
max_x = -10000
max_y = -10000
min_x = 10000
min_y = 10000
for waypoint in curvy_waypoints:
if waypoint.transform.location.x < min_x:
min_x = waypoint.transform.location.x
if waypoint.transform.location.x > max_x:
max_x = waypoint.transform.location.x
if waypoint.transform.location.y < min_y:
min_y = waypoint.transform.location.y
if waypoint.transform.location.y > max_y:
max_y = waypoint.transform.location.y
mid_x = (max_x + min_x) / 2
mid_y = (max_y + min_y) / 2
print("mid_x, mid_y " + str(mid_x) + " " + str(mid_y))
start_time = time.clock()
section = 1
while True:
loc = vehicle.get_location()
#print(loc)
if section == 1:
if loc.y < mid_y:
first_quarter_time = time.clock() - start_time
section = 2
start_time = time.clock()
print("first time: " + str(first_quarter_time))
continue
if section == 2:
if loc.x < mid_x:
second_quarter_time = time.clock() - start_time
section = 3
start_time = time.clock()
if section == 3:
if loc.y > mid_y:
third_quarter_time = time.clock() - start_time
section = 4
start_time = time.clock()
continue
if section == 4:
if loc.x > mid_x:
fourth_quarter_time = time.clock() - start_time
section = 1
start_time = time.clock()
continue
#Update the camera view
spectator.set_transform(camera.get_transform())
#Get next waypoint
waypoint = curvy_waypoints[i]
if (vehicle.get_location().distance(
curvy_waypoints[i].transform.location) < 20):
i = i + 1
world.debug.draw_point(waypoint.transform.location, life_time=5)
#Control vehicle's throttle and steering
throttle = 0.5
vehicle_transform = vehicle.get_transform()
vehicle_location = vehicle_transform.location
steer = control_pure_pursuit(vehicle_transform, waypoint.transform,
max_steer, wheelbase, world)
control = carla.VehicleControl(throttle, steer)
vehicle.apply_control(control)
#print("steer: " + str(steer))
time.sleep(0.1)
def main():
global df
global actor_list
### CONSTANTS ###
target_lane = -3 #Center lane is -3
target_speed = 30 #Target speed of vehicle
i = 0 # Starting waypoint
waypoint_spacing = 40 #Distance between each waypoints in
### ###
#Connect with Carla
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(10.0)
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
#xodr_path = "Crossing8Course.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 50.0 # in meters
wall_height = 1.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data, carla.OpendriveGenerationParameters(
vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
map = world.get_map()
#Setup spectator to be used to move the view with the car as it drives
spectator = world.get_spectator()
#Take only the waypoints from the targetLane
waypoint_list = map.generate_waypoints(waypoint_spacing)
waypoints = single_lane(waypoint_list, target_lane)
waypoints = get_curvy_waypoints(waypoints)
spawnpoint = waypoints[i]
#SET CUSTOM WAYPOINTS HERE WITH PATH PLANNING
#Spawn vehicle, attach the spectator camera, and add the controller
vehicle, camera, controller = spawn_actor(world, spawnpoint)
print("Vehicle spawned at " + str(spawnpoint))
while True:
#Plot point on pyplot graph
loc = vehicle.get_location()
plt.plot(loc.x,loc.y, marker = 'o', color = 'r', markersize = 2)
#Log point for export in csv/excel
#Rotate into the car's frame
vehicle_rotation = vehicle.get_transform().rotation
point = [[time.clock(), loc.x, loc.y, vehicle.get_velocity().x, vehicle.get_velocity().y, vehicle_rotation.yaw]]
print(point)
df = df.append(point, ignore_index=True,sort=False)
#Update the camera view
spectator.set_transform(camera.get_transform())
# Replace this section to add local path planning
###
waypoint = waypoints[i]
#Get next waypoint
if(vehicle.get_location().distance(waypoints[i].transform.location) < 30):
i = i + 1
if i >= len(waypoints) - 1:
i = 0
world.debug.draw_point(waypoint.transform.location, life_time=5)
plt.plot(waypoint.transform.location.x, waypoint.transform.location.y, color = 'g', marker = 'o', markersize = 2)
###
#Control vehicle's throttle and steering
vehicle_transform = vehicle.get_transform()
speed = math.sqrt(vehicle.get_velocity().x ** 2 + vehicle.get_velocity().y ** 2)
#print("speed: " + str(vehicle.get_velocity()))
throttle = controller.throttle_control(speed)
#throttle = 0 # for set velocity
steer = controller.steering_control(vehicle_transform, waypoint.transform)
control = carla.VehicleControl(throttle, steer)
#velocity_vector = carla.Vector3D(vehicle_transform.get_forward_vector())
#velocity_vector = carla.Vector3D(20, 0, 0)
#vehicle.set_velocity(velocity_vector)
#print("VV " + str(velocity_vector))
vehicle.apply_control(control)
print("throttle, steer: " + str(throttle) + ", " + str(steer))
plt.axis([-500, 1500, -800, 100])
plt.savefig("path.png")
def _set_carla_town(self):
"""
Extract the CARLA town (level) from the RoadNetwork information from OpenSCENARIO
Note: The specification allows multiple Logics elements within the RoadNetwork element.
Hence, there can be multiple towns specified. We just use the _last_ one.
"""
for logic in self.xml_tree.find("RoadNetwork").findall("LogicFile"):
self.town = logic.attrib.get('filepath', None)
if self.town is not None and ".xodr" in self.town:
if not os.path.isabs(self.town):
self.town = os.path.dirname(os.path.abspath(self.filename)) + "/" + self.town
if not os.path.exists(self.town):
raise AttributeError("The provided RoadNetwork '{}' does not exist".format(self.town))
# workaround for relative positions during init
world = self.client.get_world()
wmap = None
if world:
world.get_settings()
wmap = world.get_map()
if world is None or (wmap is not None and wmap.name.split('/')[-1] != self.town):
if ".xodr" in self.town:
with open(self.town, 'r', encoding='utf-8') as od_file:
data = od_file.read()
index = data.find('<OpenDRIVE>')
data = data[index:]
old_map = ""
if wmap is not None:
old_map = wmap.to_opendrive()
index = old_map.find('<OpenDRIVE>')
old_map = old_map[index:]
if data != old_map:
self.logger.warning(" Wrong OpenDRIVE map in use. Forcing reload of CARLA world")
vertex_distance = 2.0 # in meters
wall_height = 1.0 # in meters
extra_width = 0.6 # in meters
world = self.client.generate_opendrive_world(str(data),
carla.OpendriveGenerationParameters(
vertex_distance=vertex_distance,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
else:
self.logger.warning(" Wrong map in use. Forcing reload of CARLA world")
self.client.load_world(self.town)
world = self.client.get_world()
CarlaDataProvider.set_world(world)
if CarlaDataProvider.is_sync_mode():
world.tick()
else:
world.wait_for_tick()
else:
CarlaDataProvider.set_world(world)
def main():
client = carla.Client('127.0.0.1', 2000)
client.set_timeout(10.0)
# Read the opendrive file to a string
xodr_path = "speedway_5lanes.xodr"
#xodr_path = "Crossing8Course.xodr"
od_file = open(xodr_path)
data = od_file.read()
# Load the opendrive map
vertex_distance = 2.0 # in meters
max_road_length = 50.0 # in meters
wall_height = 1.0 # in meters
extra_width = 0.6 # in meters
world = client.generate_opendrive_world(
data,
carla.OpendriveGenerationParameters(vertex_distance=vertex_distance,
max_road_length=max_road_length,
wall_height=wall_height,
additional_width=extra_width,
smooth_junctions=True,
enable_mesh_visibility=True))
blueprint_library = world.get_blueprint_library()
blueprint = blueprint_library.filter('vehicle.*model3*')[0]
spawn_points = world.get_map().get_spawn_points(
) # get_spawn_points() returns list(carla.Transform)
spawn_point = spawn_points[0]
#world.spawn_actor(blueprint, spawn_point)
vehicle = world.spawn_actor(blueprint, spawn_point)
vehicle.apply_control(carla.VehicleControl(throttle=1.0, steer=0.0))
actor_list.append(vehicle)
cam_bp = blueprint_library.find("sensor.camera.rgb")
cam_bp.set_attribute("image_size_x", f"{IM_WIDTH}")
cam_bp.set_attribute("image_size_y", f"{IM_HEIGHT}")
cam_bp.set_attribute("fov", "110")
spawn_point = carla.Transform(carla.Location(x=2.5, z=0.7))
sensor = world.spawn_actor(cam_bp, spawn_point, attach_to=vehicle)
actor_list.append(sensor)
#sensor.listen(lambda data: process_img(data))
l_images = []
sensor.listen(lambda data: process_img(data, l_images))
time.sleep(1)
sensor.stop()
for im in l_images:
cv2.imshow('image', im)
cv2.waitKey(16)
#dir() - to see all the attributes?
for i in range(10):
location = vehicle.get_location()
print(location)
time.sleep(1)
