def main(obj):
"""
Take in some optional arguments for configuring the simulator network settings
(specifically where the simulator should be listening for incoming connections
from Framer)
"""
argparser = argparse.ArgumentParser(
description='CARLA Manual Control Client')
argparser.add_argument(
'-v', '--verbose',
action='store_true',
dest='debug',
help='print debug information')
argparser.add_argument(
'--host',
metavar='H',
default=REMOTE_IP,
help='IP of the host server (default: localhost)')
argparser.add_argument(
'-p', '--port',
metavar='P',
default=REMOTE_PORT,
type=int,
help='TCP port to listen to (default: 2000)')
args = argparser.parse_args()
log_level = logging.DEBUG if args.debug else logging.INFO
logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)
logging.info('listening to server %s:%s', args.host, args.port)
while True:
try:
"""
Construct server here
When we get a response then start client
"""
print("trying server", args.host, args.port, make_carla_client(args.host, args.port))
# Construct an instance of the CARLA simulator and save it to a global (threading)
with make_carla_client(args.host, args.port) as client:
global game
game = CarlaGame(client, args)
print("execute")
game.execute()
break
except TCPConnectionError as error:
print("error")
logging.error(error)
time.sleep(1)
def collect_loop(args):
try:
carla_process, out = open_carla(args.port, args.town_name, args.gpu,
args.container_name)
while True:
try:
with make_carla_client(args.host, args.port) as client:
collect(client, args)
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
# KILL CARLA TO AVOID ZOMBIES
carla_process.kill()
subprocess.call(['docker', 'stop', out[:-1]])
except KeyboardInterrupt:
print('Killed By User')
carla_process.kill()
subprocess.call(['docker', 'stop', out[:-1]])
except:
carla_process.kill()
subprocess.call(['docker', 'stop', out[:-1]])
def main():
rospy.init_node("carla_client", anonymous=True)
params = rospy.get_param('carla')
host = params['host']
port = params['port']
rospy.loginfo("Trying to connect to {host}:{port}".format(
host=host, port=port))
with make_carla_client(host, port) as client:
rospy.loginfo("Connected")
# Where should the car start
start_position = rospy.get_param('starting_location')
# What distance should the vehicle travel
distance_experiment = 500
# if the gt is logged, a bag file will be created.
if rospy.get_param('log_gt', True):
bridge_cls = CarlaRosBridgeWithBagExperiment(client=client, params=params, start_position=start_position, distance_experiment=distance_experiment)
else:
bridge_cls = CarlaRosBridgeExperiment(client=client, params=params, start_position=start_position, distance_experiment=distance_experiment)
with bridge_cls as carla_ros_bridge:
rospy.on_shutdown(carla_ros_bridge.on_shutdown)
carla_ros_bridge.run()
def main():
argparser = argparse.ArgumentParser(
description='CARLA Manual Control Client')
argparser.add_argument(
'-v', '--verbose',
action='store_true',
dest='debug',
help='print debug information')
argparser.add_argument(
'--host',
metavar='H',
default='localhost',
help='IP of the host server (default: localhost)')
argparser.add_argument(
'-p', '--port',
metavar='P',
default=2000,
type=int,
help='TCP port to listen to (default: 2000)')
argparser.add_argument(
'-a', '--autopilot',
action='store_true',
help='enable autopilot')
argparser.add_argument(
'-l', '--lidar',
action='store_true',
help='enable Lidar')
argparser.add_argument(
'-q', '--quality-level',
choices=['Low', 'Epic'],
type=lambda s: s.title(),
default='Epic',
help='graphics quality level, a lower level makes the simulation run considerably faster.')
argparser.add_argument(
'-m', '--map-name',
metavar='M',
default=None,
help='plot the map of the current city (needs to match active map in '
'server, options: Town01 or Town02)')
args = argparser.parse_args()
log_level = logging.DEBUG if args.debug else logging.INFO
logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)
logging.info('listening to server %s:%s', args.host, args.port)
print(__doc__)
wrapper = Carla_Wrapper()
while True:
try:
with make_carla_client(args.host, args.port) as client:
game = CarlaGame(client, args, wrapper)
game.execute()
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
def main():
argparser = generate_run_arguments()
argparser.add_argument('-e',
'--every-second',
default=0.2,
type=float,
help='Save measurements every -e seconds')
args = argparser.parse_args()
log_level = logging.DEBUG if args.debug else logging.INFO
logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)
logging.info('listening to server %s:%s', args.host, args.port)
print(__doc__)
out_directory = create_out_directory()
save_run_config(out_directory, args)
while True:
try:
with make_carla_client(args.host, args.port) as client:
game = CarlaGame(client, args)
game.execute(out_directory, args.frames, args.every_second)
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
def main():
rospy.init_node("carla_client", anonymous=True)
params = rospy.get_param('carla')
host = params['host']
port = params['port']
num_episodes = params['Episodes']
rospy.loginfo("Trying to connect to {host}:{port}".format(host=host,
port=port))
with make_carla_client(host, port) as client:
rospy.loginfo("Connected")
for episode in range(0, num_episodes):
if rospy.is_shutdown():
break
rospy.loginfo("Starting Episode --> {}".format(episode))
current_eps = '_episode' + '_' + str(episode)
rospy.set_param(param_name='curr_episode', param_value=current_eps)
bridge_cls = CarlaRosBridgeWithBag if rospy.get_param(
'rosbag_fname', '') else CarlaRosBridge
with bridge_cls(client=client, params=params) as carla_ros_bridge:
rospy.on_shutdown(carla_ros_bridge.on_shutdown)
carla_ros_bridge.run()
def run_driving_benchmark(agent,
experiment_suite,
city_name='Town01',
log_name='Test',
continue_experiment=False,
host='127.0.0.1',
port=2000):
while True:
try:
with make_carla_client(host, port) as client:
# Hack to fix for the issue 310, we force a reset, so it does not get
# the positions on first server reset.
client.load_settings(CarlaSettings())
client.start_episode(0)
# We instantiate the driving benchmark, that is the engine used to
# benchmark an agent. The instantiation starts the log process, sets
benchmark = DrivingBenchmark(
city_name=city_name,
name_to_save=log_name + '_' +
type(experiment_suite).__name__ + '_' + city_name,
continue_experiment=continue_experiment)
# This function performs the benchmark. It returns a dictionary summarizing
# the entire execution.
benchmark_summary = benchmark.benchmark_agent(
experiment_suite, agent, client)
print("")
print("")
print(
"----- Printing results for training weathers (Seen in Training) -----"
)
print("")
print("")
av = results_printer.print_summary(
benchmark_summary, experiment_suite.train_weathers,
benchmark.get_path())
open(
'/home/rsi/Desktop/CAL/PythonClient/_benchmarks_results/' +
log_name + '_av_succ_' + str(av) + '.txt', 'w')
print("")
print("")
print(
"----- Printing results for test weathers (Unseen in Training) -----"
)
print("")
print("")
results_printer.print_summary(benchmark_summary,
experiment_suite.test_weathers,
benchmark.get_path())
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(2)
def Control(args, con):
with make_carla_client(args.host, args.port) as client:
game = simulator.CarlaGame(client, args)
game.initialize_game()
#game.new_game()
timer = Timer()
throttle, brake, steer = 0, 0, 0
while True:
timer.tick()
if timer.elapsed_seconds_since_lap() >= 0.1:
#throttle, brake, steer= con.pp_control()
#throttle, brake, steer= con.pp_control()
throttle, brake, steer = con.stanely_control()
print('setV realV acc brake')
print(round(con.state.setV, 2), round(con.state.v, 2),
round(throttle, 2), round(brake, 2))
print('cmd -> throttle, brake, steer')
print(round(throttle, 2), round(brake, 2), round(steer, 2))
print('\n')
con.state = game.frame_step(steer, throttle, brake)
#con.state = game.frame_step(0, throttle, brake)
con.render()
timer.lap()
if False:
game.new_game()
con.state = game.frame_step(steer, throttle, brake)
time.sleep(0.025)
pass
def main():
argparser = argparse.ArgumentParser(
description='CARLA Manual Control Client')
argparser.add_argument('-v',
'--verbose',
action='store_true',
dest='debug',
help='print debug information')
argparser.add_argument('--host',
metavar='H',
default='localhost',
help='IP of the host server (default: localhost)')
argparser.add_argument('-p',
'--port',
metavar='P',
default=2000,
type=int,
help='TCP port to listen to (default: 2000)')
argparser.add_argument('-a',
'--autopilot',
action='store_true',
help='enable autopilot')
argparser.add_argument('-l',
'--lidar',
action='store_true',
help='enable Lidar')
argparser.add_argument(
'-q',
'--quality-level',
choices=['Low', 'Epic'],
type=lambda s: s.title(),
default='Epic',
help=
'graphics quality level, a lower level makes the simulation run considerably faster'
)
argparser.add_argument('-m',
'--map',
action='store_true',
help='plot the map of the current city')
args = argparser.parse_args()
log_level = logging.DEBUG if args.debug else logging.INFO
logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)
logging.info('listening to server %s:%s', args.host, args.port)
# print(__doc__)
# os.system("gnome-terminal -e 'bash -c \"cd /home/kadn/AUTODRIVING/carla_python && ./CarlaUE4.sh -windowed -ResX=650 -ResY=350 -carla-server; exec bash\"'")
while True:
try:
with make_carla_client(args.host, args.port) as client:
game = CarlaGame(client, args)
game.execute()
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
def start_gathering_data(args, out_directory):
with make_carla_client(args.host, args.port) as client:
settings = get_settings_for_scene(args)
scene = client.load_settings(settings)
# Choose one player start at random.
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0, number_of_player_starts - 1))
client.start_episode(player_start)
skip_frames = args.skip_frames # make screen every skip_frames
with open(out_directory + '\\' + MEASUREMENTS_CSV_FILENAME, 'w', newline='') as csvfile:
measurements_file = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
# let skip first 20 frames (car is in the air)
for _ in range(20):
measurements, sensor_data = client.read_data()
logging.info("Skipping frames...")
control = measurements.player_measurements.autopilot_control
client.send_control(control)
frame = 0
saved_frames = 0
last_log_skip_frame = 0
while True:
measurements, sensor_data = client.read_data()
# if car is standing than data is ignored
if measurements.player_measurements.forward_speed <= 0.1 and measurements.player_measurements.autopilot_control.throttle == 0:
if last_log_skip_frame != frame:
logging.info("[{}] Car is stopped, skip saving screen...".format(frame))
last_log_skip_frame = frame
control = measurements.player_measurements.autopilot_control
client.send_control(control)
continue
if frame % skip_frames == 0:
saved_frames = saved_frames + 1
logging.info("[SAVE] {}/{}: steering: {}, acc: {}, brake: {} ".format(
saved_frames,
args.frames,
measurements.player_measurements.autopilot_control.steer,
measurements.player_measurements.autopilot_control.throttle,
measurements.player_measurements.autopilot_control.brake))
write_measurements_to_csv(measurements_file, frame, measurements.player_measurements.autopilot_control)
for name, measurement in sensor_data.items():
save_frame_image(out_directory, frame, measurement, name)
frame = frame + 1
control = measurements.player_measurements.autopilot_control
client.send_control(control)
if saved_frames >= args.frames:
logging.info("Saved frames: {}; STOP".format(saved_frames))
break
def view_start_positions(args):
# We assume the CARLA server is already waiting for a client to connect at
# host:port. The same way as in the client example.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
# We load the default settings to the client.
scene = client.load_settings(CarlaSettings())
print("Received the start positions")
# We get the number of player starts, in order to detect the city.
number_of_player_starts = len(scene.player_start_spots)
if number_of_player_starts > 100: # WARNING: unsafe way to check for city, see issue #313
image = mpimg.imread("carla/planner/Town01.png")
carla_map = CarlaMap('Town01', 0.1653, 50)
else:
image = mpimg.imread("carla/planner/Town02.png")
carla_map = CarlaMap('Town02', 0.1653, 50)
fig, ax = plt.subplots(1)
ax.imshow(image)
if args.positions == 'all':
positions_to_plot = range(len(scene.player_start_spots))
else:
positions_to_plot = map(int, args.positions.split(','))
for position in positions_to_plot:
# Check if position is valid
if position >= len(scene.player_start_spots):
raise RuntimeError('Selected position is invalid')
# Convert world to pixel coordinates
pixel = carla_map.convert_to_pixel([
scene.player_start_spots[position].location.x,
scene.player_start_spots[position].location.y,
scene.player_start_spots[position].location.z
])
circle = Circle((pixel[0], pixel[1]),
12,
color='r',
label='A point')
ax.add_patch(circle)
if not args.no_labels:
plt.text(pixel[0], pixel[1], str(position), size='x-small')
plt.axis('off')
plt.show()
fig.savefig('town_positions.pdf',
orientation='landscape',
bbox_inches='tight')
def main():
argparser = argparse.ArgumentParser(
description='CARLA Manual Control Client')
argparser.add_argument(
'-v', '--verbose',
action='store_true',
dest='debug',
help='print debug information')
argparser.add_argument(
'--host',
metavar='H',
default='localhost',
help='IP of the host server (default: localhost)')
argparser.add_argument(
'-p', '--port',
metavar='P',
default=2000,
type=int,
help='TCP port to listen to (default: 2000)')
argparser.add_argument(
'-a', '--autopilot',
action='store_true',
help='enable autopilot')
argparser.add_argument(
'-l', '--lidar',
action='store_true',
help='enable Lidar')
argparser.add_argument(
'-q', '--quality-level',
choices=['Low', 'Epic'],
type=lambda s: s.title(),
default='Epic',
help='graphics quality level, a lower level makes the simulation run considerably faster')
argparser.add_argument(
'-m', '--map',
action='store_true',
help='plot the map of the current city')
args = argparser.parse_args()
log_level = logging.DEBUG if args.debug else logging.INFO
logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)
logging.info('listening to server %s:%s', args.host, args.port)
# print(__doc__)
# os.system("gnome-terminal -e 'bash -c \"cd /home/kadn/AUTODRIVING/carla_python && ./CarlaUE4.sh -windowed -ResX=650 -ResY=350 -carla-server; exec bash\"'")
while True:
try:
with make_carla_client(args.host, args.port) as client:
game = CarlaGame(client, args)
game.execute()
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
def view_start_positions(args):
# We assume the CARLA server is already waiting for a client to connect at
# host:port. The same way as in the client example.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
# We load the default settings to the client.
scene = client.load_settings(CarlaSettings())
print("Received the start positions")
try:
print(scene.map_name)
image = mpimg.imread('./environment/%s.png' % scene.map_name)
carla_map = CarlaMap(scene.map_name, 0.1653, 50)
except IOError as exception:
logging.error(exception)
logging.error('Cannot find map "%s"', scene.map_name)
sys.exit(1)
fig, ax = plt.subplots(1)
ax.imshow(image)
if args.positions == 'all':
positions_to_plot = range(len(scene.player_start_spots))
else:
positions_to_plot = map(int, args.positions.split(','))
for position in positions_to_plot:
# Check if position is valid
if position >= len(scene.player_start_spots):
raise RuntimeError('Selected position is invalid')
# Convert world to pixel coordinates
pixel = carla_map.convert_to_pixel([
scene.player_start_spots[position].location.x,
scene.player_start_spots[position].location.y,
scene.player_start_spots[position].location.z
])
circle = Circle((pixel[0], pixel[1]),
12,
color='r',
label='A point')
ax.add_patch(circle)
if not args.no_labels:
plt.text(pixel[0], pixel[1], str(position), size='x-small')
plt.axis('off')
plt.show()
fig.savefig('town_positions.pdf',
orientation='landscape',
bbox_inches='tight')
def collect_loop(args):
while True:
try:
with make_carla_client(args.host, args.port) as client:
collect(client, args)
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
def run_carla_client(args, settings_generators):
with make_carla_client(args.host, args.port, timeout=25) as client:
for settings_generator in settings_generators:
scene = client.load_settings(settings_generator())
client.start_episode(0)
watch = FPSWatch()
for frame in range(0, 3000):
measurements, sensor_data = client.read_data()
client.send_control(measurements.player_measurements.autopilot_control)
watch.annotate()
print(str(watch))
print('done.')
def main_loop(self):
with make_carla_client(self.host, self.port) as client:
print('CarlaClient connected')
try:
while not rospy.is_shutdown():
for episode in range(0, self.number_of_episodes):
settings = self.make_carla_settings()
# Now we load these settings into the server. The server replies
# with a scene description containing the available start spots for
# the player. Here we can provide a CarlaSettings object or a
# CarlaSettings.ini file as string.
scene = client.load_settings(settings)
# Choose one player start at random.
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(
0, max(0, number_of_player_starts - 1))
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print('Starting new episode...')
client.start_episode(player_start)
rate = rospy.Rate(ROS_FREQUENCY)
# Iterate every frame in the episode.
for frame in range(0, self.frames_per_episode):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
self.measurements_process(measurements)
self.sensor_process(sensor_data)
if not self.autopilot_on:
client.send_control(steer=random.uniform(
-1.0, 1.0),
throttle=0.5,
brake=False,
hand_brake=False,
reverse=False)
else:
# Together with the measurements, the server has sent the
# control that the in-game autopilot would do this frame. We
# can enable autopilot by sending back this control to the
# server. We can modify it if wanted, here for instance we
# will add some noise to the steer.
control = measurements.player_measurements.autopilot_control
control.steer += random.uniform(-0.1, 0.1)
client.send_control(control)
rate.sleep()
except KeyboardInterrupt:
pass
def main():
host, port = 'localhost', 2000
while True:
try:
with make_carla_client(host, port) as client:
driver = AutoDriver(client, 'Town01')
driver.start()
break
except TCPConnectionError:
# logging error
raise
def run_driving_benchmark(agent,
experiment_suite,
city_name='Town01',
log_name='Test',
continue_experiment=False,
host='127.0.0.1',
port=2000
):
while True:
try:
with make_carla_client(host, port) as client:
# Hack to fix for the issue 310, we force a reset, so it does not get
# the positions on first server reset.
client.load_settings(CarlaSettings())
client.start_episode(0)
# We instantiate the driving benchmark, that is the engine used to
# benchmark an agent. The instantiation starts the log process, sets
benchmark = DrivingBenchmark(city_name=city_name,
name_to_save=log_name + '_'
+ type(experiment_suite).__name__
+ '_' + city_name,
continue_experiment=continue_experiment)
# This function performs the benchmark. It returns a dictionary summarizing
# the entire execution.
benchmark_summary = benchmark.benchmark_agent(experiment_suite, agent, client)
print("")
print("")
print("----- Printing results for training weathers (Seen in Training) -----")
print("")
print("")
results_printer.print_summary(benchmark_summary, experiment_suite.train_weathers,
benchmark.get_path())
print("")
print("")
print("----- Printing results for test weathers (Unseen in Training) -----")
print("")
print("")
results_printer.print_summary(benchmark_summary, experiment_suite.test_weathers,
benchmark.get_path())
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
def main():
argparser = argparse.ArgumentParser(
description='CARLA Manual Control Client')
argparser.add_argument('-v',
'--verbose',
action='store_true',
dest='debug',
help='print debug information')
argparser.add_argument('--host',
metavar='H',
default='localhost',
help='IP of the host server (default: localhost)')
argparser.add_argument('-p',
'--port',
metavar='P',
default=2000,
type=int,
help='TCP port to listen to (default: 2000)')
argparser.add_argument(
'-m',
'--map-name',
metavar='M',
default=None,
help=
'plot the map of the current city (needs to match active map in server, options: Town01 or Town02)'
)
args = argparser.parse_args()
log_level = logging.DEBUG if args.debug else logging.INFO
logging.basicConfig(filename='carlaClient.log',
filemode='w',
format='%(levelname)s: %(message)s',
level=log_level)
logging.info('listening to server %s:%s', args.host, args.port)
print(__doc__)
while True:
try:
with make_carla_client(args.host, args.port) as client:
game = CarlaGame(client, args.map_name)
game.execute()
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
except Exception as exception:
logging.exception(exception)
sys.exit(1)
def start(args):
line_points = []
skip_frames = 40
with make_carla_client(args.host, args.port) as client:
settings = get_settings_for_scene(args)
scene = client.load_settings(settings)
client.start_episode(0)
written_info_stop = False
frame = 0
while True:
frame = frame + 1
measurements, sensor_data = client.read_data()
if frame < skip_frames:
logging.info("Skipping first {} frames...".format(skip_frames))
control = measurements.player_measurements.autopilot_control
client.send_control(control)
continue
current_position = vec3tovec2(
measurements.player_measurements.transform.location)
if len(line_points) > 1:
dist_from_start = distance(line_points[0], current_position)
else:
dist_from_start = 10000
if dist_from_start < 0.5:
logging.info(
"Position: {} is already logged".format(current_position))
break
line_points.append(current_position)
points_x.append(current_position[0])
points_y.append(current_position[1])
logging.info(
"Add point: [{:.4f},{:.4f}], points count: {:0>4d}, distance from start: {:.4f}"
.format(current_position[0], current_position[1],
len(line_points), dist_from_start))
control = measurements.player_measurements.autopilot_control
if USE_SPEED_CONSTRAINTS:
if measurements.player_measurements.forward_speed * 3.6 < MINIMAL_SPEED:
acceleration = 0.7
control.throttle = acceleration
elif measurements.player_measurements.forward_speed * 3.6 > MAXIMAL_SPEED:
acceleration = 0
control.throttle = acceleration
client.send_control(control)
def execute(gpu,
exp_batch,
exp_alias,
ckpt,
model,
city_name='Town01',
memory_use=0.2,
host='127.0.0.1'):
# host,port,gpu_number,path,show_screen,resolution,noise_type,config_path,type_of_driver,experiment_name,city_name,game,drivers_name
#drive_config.city_name = city_name
# TODO Eliminate drive config.
print("Running ", __file__, " On GPU ", gpu, "of experiment name ",
exp_alias)
os.environ["CUDA_VISIBLE_DEVICES"] = gpu
sys.stdout = open(str(os.getpid()) + ".out", "a", buffering=1)
carla_process, port = start_carla_simulator(gpu, exp_batch, exp_alias,
city_name)
merge_with_yaml(os.path.join(exp_batch, exp_alias + '.yaml'))
set_type_of_process('test')
experiment_suite = TestSuite()
# coil_icra, coil_unit, wgangp_lsd, unit_task_only
architecture_name = model
while True:
try:
with make_carla_client(host, port) as client:
checkpoint = torch.load(os.path.join(ckpt))
coil_agent = CoILAgent(checkpoint, architecture_name)
run_driving_benchmark(
coil_agent, experiment_suite, city_name,
exp_batch + '_' + exp_alias + 'iteration', False, host,
port)
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
carla_process.kill()
except KeyboardInterrupt:
carla_process.kill()
except:
traceback.print_exc()
carla_process.kill()
carla_process.kill()
def main():
args = parse_args()
log_level = logging.DEBUG if args.debug else logging.INFO
logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)
logging.info('listening to server %s:%s', args.host, args.port)
logging.info(__doc__)
while True:
try:
with make_carla_client(args.host, args.port) as client:
game = CarlaGame(client, args)
game.execute()
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
def view_start_positions(args):
# We assume the CARLA server is already waiting for a client to connect at
# host:port. The same way as in the client example.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
# We load the default settings to the client.
scene = client.load_settings(CarlaSettings())
print("Received the start positions")
try:
image = mpimg.imread('carla/planner/%s.png' % scene.map_name)
carla_map = CarlaMap(scene.map_name, 0.1653, 50)
except IOError as exception:
logging.error(exception)
logging.error('Cannot find map "%s"', scene.map_name)
sys.exit(1)
fig, ax = plt.subplots(1)
ax.imshow(image)
if args.positions == 'all':
positions_to_plot = range(len(scene.player_start_spots))
else:
positions_to_plot = map(int, args.positions.split(','))
for position in positions_to_plot:
# Check if position is valid
if position >= len(scene.player_start_spots):
raise RuntimeError('Selected position is invalid')
# Convert world to pixel coordinates
pixel = carla_map.convert_to_pixel([scene.player_start_spots[position].location.x,
scene.player_start_spots[position].location.y,
scene.player_start_spots[position].location.z])
circle = Circle((pixel[0], pixel[1]), 12, color='r', label='A point')
ax.add_patch(circle)
if not args.no_labels:
plt.text(pixel[0], pixel[1], str(position), size='x-small')
plt.axis('off')
plt.show()
fig.savefig('town_positions.pdf', orientation='landscape', bbox_inches='tight')
def main():
rospy.init_node("carla_client", anonymous=True)
params = rospy.get_param('carla')
host = params['host']
port = params['port']
rospy.loginfo("Trying to connect to {host}:{port}".format(
host=host, port=port))
with make_carla_client(host, port) as client:
rospy.loginfo("Connected")
bridge_cls = CarlaRosBridgeWithBag if rospy.get_param(
'rosbag_fname', '') else CarlaRosBridge
with bridge_cls(client=client, params=params) as carla_ros_bridge:
rospy.on_shutdown(carla_ros_bridge.on_shutdown)
carla_ros_bridge.run()
def __enter__(self):
if 'torcs' in self.args.env:
import gym
from .TORCS.torcs_wrapper import TorcsWrapper
self.env = gym.make('TORCS-v0')
self.env.init(isServer=self.args.server,
continuous=True,
resize=not self.args.eval,
ID=self.args.id)
return TorcsWrapper(self.env)
elif 'carla' in self.args.env:
from carla.client import make_carla_client
from .CARLA.carla_env import CarlaEnv
with make_carla_client('localhost', 2019) as client:
return CarlaEnv(client)
elif 'gta' in self.args.env:
from .GTAV.gta_env import GtaEnv
from .GTAV.gta_wrapper import GTAWrapper
return GTAWrapper(GtaEnv(autodrive=None))
def start_game(args):
pygame.init()
with make_carla_client(args.host, args.port) as client:
settings = CarlaSettings()
settings.set(
SynchronousMode=False,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=3,
NumberOfPedestrians=40,
WeatherId=1,
QualityLevel="Low")
settings.randomize_seeds()
scene = client.load_settings(settings)
screen, img, dim, scale = setup_game_window(scene)
town_map = CarlaMap(scene.map_name, 0.1653, 50)
client.start_episode(7)
while running:
manage_events(pygame.event.get())
screen.blit(img, (0, 0))
play_frame(client, town_map, screen, dim, scale)
pygame.display.flip()
def view_start_positions(args):
# We assume the CARLA server is already waiting for a client to connect at
# host:port. The same way as in the client example.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
# We load the default settings to the client.
scene = client.load_settings(CarlaSettings())
print("Received the start positions")
try:
image = mpimg.imread('carla/planner/%s.png' % scene.map_name)
carla_map = CarlaMap(scene.map_name, 0.1653, 50)
except IOError as exception:
logging.error(exception)
logging.error('Cannot find map "%s"', scene.map_name)
sys.exit(1)
fig, ax = plt.subplots(1)
plt.ion()
ax.imshow(image)
if args.positions == 'all':
positions_to_plot = range(len(scene.player_start_spots))
else:
positions_to_plot = map(int, args.positions.split(','))
while True:
measurements, sensor_data = client.read_data()
current_x = measurements.player_measurements.transform.location.x
current_y = measurements.player_measurements.transform.location.y
pixel = carla_map.convert_to_pixel([current_x, current_y, 0])
circle = Circle((pixel[0], pixel[1]), 12, color='k', label='car')
ax.add_patch(circle)
plt.pause(0.05)
def view_start_positions(args):
# We assume the CARLA server is already waiting for a client to connect at
# host:port. The same way as in the client example.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
# We load the default settings to the client.
scene = client.load_settings(CarlaSettings())
print("Received the start positions")
try:
image = mpimg.imread('carla/planner/%s.png' % scene.map_name)
carla_map = CarlaMap(scene.map_name, 0.1653, 50)
except IOError as exception:
logging.error(exception)
logging.error('Cannot find map "%s"', scene.map_name)
sys.exit(1)
fig, ax = plt.subplots(1)
plt.ion()
ax.imshow(image)
if args.positions == 'all':
positions_to_plot = range(len(scene.player_start_spots))
else:
positions_to_plot = map(int, args.positions.split(','))
while True:
measurements, sensor_data = client.read_data()
current_x = measurements.player_measurements.transform.location.x
current_y = measurements.player_measurements.transform.location.y
pixel = carla_map.convert_to_pixel([current_x,current_y,0])
circle = Circle((pixel[0], pixel[1]), 12, color='k', label='car')
ax.add_patch(circle)
plt.pause(0.05)
def exec_waypoint_nav_demo(args):
""" Executes waypoint navigation demo.
"""
with make_carla_client(args.host, args.port) as client:
print('Carla client connected.')
settings = make_carla_settings(args)
# Now we load these settings into the server. The server replies
# with a scene description containing the available start spots for
# the player. Here we can provide a CarlaSettings object or a
# CarlaSettings.ini file as string.
scene = client.load_settings(settings)
# Refer to the player start folder in the WorldOutliner to see the
# player start information
player_start = PLAYER_START_INDEX
client.start_episode(player_start)
time.sleep(CLIENT_WAIT_TIME);
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print('Starting new episode at %r...' % scene.map_name)
client.start_episode(player_start)
#############################################
# Load Configurations
#############################################
# Load configuration file (options.cfg) and then parses for the various
# options. Here we have two main options:
# live_plotting and live_plotting_period, which controls whether
# live plotting is enabled or how often the live plotter updates
# during the simulation run.
config = configparser.ConfigParser()
config.read(os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'options.cfg'))
demo_opt = config['Demo Parameters']
# Get options
enable_live_plot = demo_opt.get('live_plotting', 'true').capitalize()
enable_live_plot = enable_live_plot == 'True'
live_plot_period = float(demo_opt.get('live_plotting_period', 0))
# Set options
live_plot_timer = Timer(live_plot_period)
#############################################
# Load stop sign and parked vehicle parameters
# Convert to input params for LP
#############################################
# Stop sign (X(m), Y(m), Z(m), Yaw(deg))
stopsign_data = None
stopsign_fences = [] # [x0, y0, x1, y1]
with open(C4_STOP_SIGN_FILE, 'r') as stopsign_file:
next(stopsign_file) # skip header
stopsign_reader = csv.reader(stopsign_file,
delimiter=',',
quoting=csv.QUOTE_NONNUMERIC)
stopsign_data = list(stopsign_reader)
# convert to rad
for i in range(len(stopsign_data)):
stopsign_data[i][3] = stopsign_data[i][3] * np.pi / 180.0
# obtain stop sign fence points for LP
for i in range(len(stopsign_data)):
x = stopsign_data[i][0]
y = stopsign_data[i][1]
z = stopsign_data[i][2]
yaw = stopsign_data[i][3] + np.pi / 2.0 # add 90 degrees for fence
spos = np.array([
[0, 0 ],
[0, C4_STOP_SIGN_FENCELENGTH]])
rotyaw = np.array([
[np.cos(yaw), np.sin(yaw)],
[-np.sin(yaw), np.cos(yaw)]])
spos_shift = np.array([
[x, x],
[y, y]])
spos = np.add(np.matmul(rotyaw, spos), spos_shift)
stopsign_fences.append([spos[0,0], spos[1,0], spos[0,1], spos[1,1]])
# Parked car(s) (X(m), Y(m), Z(m), Yaw(deg), RADX(m), RADY(m), RADZ(m))
parkedcar_data = None
parkedcar_box_pts = [] # [x,y]
with open(C4_PARKED_CAR_FILE, 'r') as parkedcar_file:
next(parkedcar_file) # skip header
parkedcar_reader = csv.reader(parkedcar_file,
delimiter=',',
quoting=csv.QUOTE_NONNUMERIC)
parkedcar_data = list(parkedcar_reader)
# convert to rad
for i in range(len(parkedcar_data)):
parkedcar_data[i][3] = parkedcar_data[i][3] * np.pi / 180.0
# obtain parked car(s) box points for LP
for i in range(len(parkedcar_data)):
x = parkedcar_data[i][0]
y = parkedcar_data[i][1]
z = parkedcar_data[i][2]
yaw = parkedcar_data[i][3]
xrad = parkedcar_data[i][4]
yrad = parkedcar_data[i][5]
zrad = parkedcar_data[i][6]
cpos = np.array([
[-xrad, -xrad, -xrad, 0, xrad, xrad, xrad, 0 ],
[-yrad, 0, yrad, yrad, yrad, 0, -yrad, -yrad]])
rotyaw = np.array([
[np.cos(yaw), np.sin(yaw)],
[-np.sin(yaw), np.cos(yaw)]])
cpos_shift = np.array([
[x, x, x, x, x, x, x, x],
[y, y, y, y, y, y, y, y]])
cpos = np.add(np.matmul(rotyaw, cpos), cpos_shift)
for j in range(cpos.shape[1]):
parkedcar_box_pts.append([cpos[0,j], cpos[1,j]])
#############################################
# Load Waypoints
#############################################
# Opens the waypoint file and stores it to "waypoints"
waypoints_file = WAYPOINTS_FILENAME
waypoints_filepath =\
os.path.join(os.path.dirname(os.path.realpath(__file__)),
WAYPOINTS_FILENAME)
waypoints_np = None
with open(waypoints_filepath) as waypoints_file_handle:
waypoints = list(csv.reader(waypoints_file_handle,
delimiter=',',
quoting=csv.QUOTE_NONNUMERIC))
waypoints_np = np.array(waypoints)
#############################################
# Controller 2D Class Declaration
#############################################
# This is where we take the controller2d.py class
# and apply it to the simulator
controller = controller2d.Controller2D(waypoints)
#############################################
# Determine simulation average timestep (and total frames)
#############################################
# Ensure at least one frame is used to compute average timestep
num_iterations = ITER_FOR_SIM_TIMESTEP
if (ITER_FOR_SIM_TIMESTEP < 1):
num_iterations = 1
# Gather current data from the CARLA server. This is used to get the
# simulator starting game time. Note that we also need to
# send a command back to the CARLA server because synchronous mode
# is enabled.
measurement_data, sensor_data = client.read_data()
sim_start_stamp = measurement_data.game_timestamp / 1000.0
# Send a control command to proceed to next iteration.
# This mainly applies for simulations that are in synchronous mode.
send_control_command(client, throttle=0.0, steer=0, brake=1.0)
# Computes the average timestep based on several initial iterations
sim_duration = 0
for i in range(num_iterations):
# Gather current data
measurement_data, sensor_data = client.read_data()
# Send a control command to proceed to next iteration
send_control_command(client, throttle=0.0, steer=0, brake=1.0)
# Last stamp
if i == num_iterations - 1:
sim_duration = measurement_data.game_timestamp / 1000.0 -\
sim_start_stamp
# Outputs average simulation timestep and computes how many frames
# will elapse before the simulation should end based on various
# parameters that we set in the beginning.
SIMULATION_TIME_STEP = sim_duration / float(num_iterations)
print("SERVER SIMULATION STEP APPROXIMATION: " + \
str(SIMULATION_TIME_STEP))
TOTAL_EPISODE_FRAMES = int((TOTAL_RUN_TIME + WAIT_TIME_BEFORE_START) /\
SIMULATION_TIME_STEP) + TOTAL_FRAME_BUFFER
#############################################
# Frame-by-Frame Iteration and Initialization
#############################################
# Store pose history starting from the start position
measurement_data, sensor_data = client.read_data()
start_timestamp = measurement_data.game_timestamp / 1000.0
start_x, start_y, start_yaw = get_current_pose(measurement_data)
send_control_command(client, throttle=0.0, steer=0, brake=1.0)
x_history = [start_x]
y_history = [start_y]
yaw_history = [start_yaw]
time_history = [0]
speed_history = [0]
collided_flag_history = [False] # assume player starts off non-collided
#############################################
# Vehicle Trajectory Live Plotting Setup
#############################################
# Uses the live plotter to generate live feedback during the simulation
# The two feedback includes the trajectory feedback and
# the controller feedback (which includes the speed tracking).
lp_traj = lv.LivePlotter(tk_title="Trajectory Trace")
lp_1d = lv.LivePlotter(tk_title="Controls Feedback")
###
# Add 2D position / trajectory plot
###
trajectory_fig = lp_traj.plot_new_dynamic_2d_figure(
title='Vehicle Trajectory',
figsize=(FIGSIZE_X_INCHES, FIGSIZE_Y_INCHES),
edgecolor="black",
rect=[PLOT_LEFT, PLOT_BOT, PLOT_WIDTH, PLOT_HEIGHT])
trajectory_fig.set_invert_x_axis() # Because UE4 uses left-handed
# coordinate system the X
# axis in the graph is flipped
trajectory_fig.set_axis_equal() # X-Y spacing should be equal in size
# Add waypoint markers
trajectory_fig.add_graph("waypoints", window_size=waypoints_np.shape[0],
x0=waypoints_np[:,0], y0=waypoints_np[:,1],
linestyle="-", marker="", color='g')
# Add trajectory markers
trajectory_fig.add_graph("trajectory", window_size=TOTAL_EPISODE_FRAMES,
x0=[start_x]*TOTAL_EPISODE_FRAMES,
y0=[start_y]*TOTAL_EPISODE_FRAMES,
color=[1, 0.5, 0])
# Add starting position marker
trajectory_fig.add_graph("start_pos", window_size=1,
x0=[start_x], y0=[start_y],
marker=11, color=[1, 0.5, 0],
markertext="Start", marker_text_offset=1)
# Add end position marker
trajectory_fig.add_graph("end_pos", window_size=1,
x0=[waypoints_np[-1, 0]],
y0=[waypoints_np[-1, 1]],
marker="D", color='r',
markertext="End", marker_text_offset=1)
# Add car marker
trajectory_fig.add_graph("car", window_size=1,
marker="s", color='b', markertext="Car",
marker_text_offset=1)
# Add lead car information
trajectory_fig.add_graph("leadcar", window_size=1,
marker="s", color='g', markertext="Lead Car",
marker_text_offset=1)
# Add stop sign position
trajectory_fig.add_graph("stopsign", window_size=1,
x0=[stopsign_fences[0][0]], y0=[stopsign_fences[0][1]],
marker="H", color="r",
markertext="Stop Sign", marker_text_offset=1)
# Add stop sign "stop line"
trajectory_fig.add_graph("stopsign_fence", window_size=1,
x0=[stopsign_fences[0][0], stopsign_fences[0][2]],
y0=[stopsign_fences[0][1], stopsign_fences[0][3]],
color="r")
# Load parked car points
parkedcar_box_pts_np = np.array(parkedcar_box_pts)
trajectory_fig.add_graph("parkedcar_pts", window_size=parkedcar_box_pts_np.shape[0],
x0=parkedcar_box_pts_np[:,0], y0=parkedcar_box_pts_np[:,1],
linestyle="", marker="+", color='b')
# Add lookahead path
trajectory_fig.add_graph("selected_path",
window_size=INTERP_MAX_POINTS_PLOT,
x0=[start_x]*INTERP_MAX_POINTS_PLOT,
y0=[start_y]*INTERP_MAX_POINTS_PLOT,
color=[1, 0.5, 0.0],
linewidth=3)
# Add local path proposals
for i in range(NUM_PATHS):
trajectory_fig.add_graph("local_path " + str(i), window_size=200,
x0=None, y0=None, color=[0.0, 0.0, 1.0])
###
# Add 1D speed profile updater
###
forward_speed_fig =\
lp_1d.plot_new_dynamic_figure(title="Forward Speed (m/s)")
forward_speed_fig.add_graph("forward_speed",
label="forward_speed",
window_size=TOTAL_EPISODE_FRAMES)
forward_speed_fig.add_graph("reference_signal",
label="reference_Signal",
window_size=TOTAL_EPISODE_FRAMES)
# Add throttle signals graph
throttle_fig = lp_1d.plot_new_dynamic_figure(title="Throttle")
throttle_fig.add_graph("throttle",
label="throttle",
window_size=TOTAL_EPISODE_FRAMES)
# Add brake signals graph
brake_fig = lp_1d.plot_new_dynamic_figure(title="Brake")
brake_fig.add_graph("brake",
label="brake",
window_size=TOTAL_EPISODE_FRAMES)
# Add steering signals graph
steer_fig = lp_1d.plot_new_dynamic_figure(title="Steer")
steer_fig.add_graph("steer",
label="steer",
window_size=TOTAL_EPISODE_FRAMES)
# live plotter is disabled, hide windows
if not enable_live_plot:
lp_traj._root.withdraw()
lp_1d._root.withdraw()
#############################################
# Local Planner Variables
#############################################
wp_goal_index = 0
local_waypoints = None
path_validity = np.zeros((NUM_PATHS, 1), dtype=bool)
lp = local_planner.LocalPlanner(NUM_PATHS,
PATH_OFFSET,
CIRCLE_OFFSETS,
CIRCLE_RADII,
PATH_SELECT_WEIGHT,
TIME_GAP,
A_MAX,
SLOW_SPEED,
STOP_LINE_BUFFER,
PREV_BEST_PATH)
bp = behavioural_planner.BehaviouralPlanner(BP_LOOKAHEAD_BASE,
stopsign_fences,
LEAD_VEHICLE_LOOKAHEAD)
#############################################
# Scenario Execution Loop
#############################################
# Iterate the frames until the end of the waypoints is reached or
# the TOTAL_EPISODE_FRAMES is reached. The controller simulation then
# ouptuts the results to the controller output directory.
reached_the_end = False
skip_first_frame = True
# Initialize the current timestamp.
current_timestamp = start_timestamp
# Initialize collision history
prev_collision_vehicles = 0
prev_collision_pedestrians = 0
prev_collision_other = 0
for frame in range(TOTAL_EPISODE_FRAMES):
# Gather current data from the CARLA server
measurement_data, sensor_data = client.read_data()
# Update pose and timestamp
prev_timestamp = current_timestamp
current_x, current_y, current_yaw = \
get_current_pose(measurement_data)
current_speed = measurement_data.player_measurements.forward_speed
current_timestamp = float(measurement_data.game_timestamp) / 1000.0
# Wait for some initial time before starting the demo
if current_timestamp <= WAIT_TIME_BEFORE_START:
send_control_command(client, throttle=0.0, steer=0, brake=1.0)
continue
else:
current_timestamp = current_timestamp - WAIT_TIME_BEFORE_START
# Store history
x_history.append(current_x)
y_history.append(current_y)
yaw_history.append(current_yaw)
speed_history.append(current_speed)
time_history.append(current_timestamp)
# Store collision history
collided_flag,\
prev_collision_vehicles,\
prev_collision_pedestrians,\
prev_collision_other = get_player_collided_flag(measurement_data,
prev_collision_vehicles,
prev_collision_pedestrians,
prev_collision_other)
collided_flag_history.append(collided_flag)
###
# Local Planner Update:
# This will use the behavioural_planner.py and local_planner.py
# implementations that the learner will be tasked with in
# the Course 4 final project
###
# Obtain Lead Vehicle information.
lead_car_pos = []
lead_car_length = []
lead_car_speed = []
for agent in measurement_data.non_player_agents:
agent_id = agent.id
if agent.HasField('vehicle'):
lead_car_pos.append(
[agent.vehicle.transform.location.x,
agent.vehicle.transform.location.y])
lead_car_length.append(agent.vehicle.bounding_box.extent.x)
lead_car_speed.append(agent.vehicle.forward_speed)
# Execute the behaviour and local planning in the current instance
# Note that updating the local path during every controller update
# produces issues with the tracking performance (imagine everytime
# the controller tried to follow the path, a new path appears). For
# this reason, the local planner (LP) will update every X frame,
# stored in the variable LP_FREQUENCY_DIVISOR, as it is analogous
# to be operating at a frequency that is a division to the
# simulation frequency.
if frame % LP_FREQUENCY_DIVISOR == 0:
# TODO Once you have completed the prerequisite functions of each of these
# lines, you can uncomment the code below the dashed line to run the planner.
# Note that functions lower in this block often require outputs from the functions
# earlier in this block, so it may be easier to implement those first to
# get a more intuitive flow of the planner.
# In addition, some of these functions have already been implemented for you,
# but it is useful for you to understand what each function is doing.
# Before you uncomment a function, please take the time to take a look at
# it and understand what is going on. It will also help inform you on the
# flow of the planner, which in turn will help you implement the functions
# flagged for you in the TODO's.
# TODO: Uncomment each code block between the dashed lines to run the planner.
# --------------------------------------------------------------
# Compute open loop speed estimate.
print("================= start ======================")
open_loop_speed = lp._velocity_planner.get_open_loop_speed(current_timestamp - prev_timestamp)
# Calculate the goal state set in the local frame for the local planner.
# Current speed should be open loop for the velocity profile generation.
ego_state = [current_x, current_y, current_yaw, open_loop_speed]
# Set lookahead based on current speed.
bp.set_lookahead(BP_LOOKAHEAD_BASE + BP_LOOKAHEAD_TIME * open_loop_speed)
# Perform a state transition in the behavioural planner.
bp.transition_state(waypoints, ego_state, current_speed)
print("The current speed = %f" % current_speed)
# Check to see if we need to follow the lead vehicle.
bp.check_for_lead_vehicle(ego_state, lead_car_pos[1])
# Compute the goal state set from the behavioural planner's computed goal state.
goal_state_set = lp.get_goal_state_set(bp._goal_index, bp._goal_state, waypoints, ego_state)
# Calculate planned paths in the local frame.
paths, path_validity = lp.plan_paths(goal_state_set)
# Transform those paths back to the global frame.
paths = local_planner.transform_paths(paths, ego_state)
# Perform collision checking.
collision_check_array = lp._collision_checker.collision_check(paths, [parkedcar_box_pts])
# Compute the best local path.
best_index = lp._collision_checker.select_best_path_index(paths, collision_check_array, bp._goal_state)
print("The best_index = %d" % best_index)
# If no path was feasible, continue to follow the previous best path.
if best_index == None:
best_path = lp.prev_best_path
else:
best_path = paths[best_index]
lp.prev_best_path = best_path
# Compute the velocity profile for the path, and compute the waypoints.
# Use the lead vehicle to inform the velocity profile's dynamic obstacle handling.
# In this scenario, the only dynamic obstacle is the lead vehicle at index 1.
desired_speed = bp._goal_state[2]
print("The desired_speed = %f" % desired_speed)
lead_car_state = [lead_car_pos[1][0], lead_car_pos[1][1], lead_car_speed[1]]
decelerate_to_stop = bp._state == behavioural_planner.DECELERATE_TO_STOP
local_waypoints = lp._velocity_planner.compute_velocity_profile(best_path, desired_speed, ego_state, current_speed, decelerate_to_stop, lead_car_state, bp._follow_lead_vehicle)
print("================= end ======================")
# --------------------------------------------------------------
if local_waypoints != None:
# Update the controller waypoint path with the best local path.
# This controller is similar to that developed in Course 1 of this
# specialization. Linear interpolation computation on the waypoints
# is also used to ensure a fine resolution between points.
wp_distance = [] # distance array
local_waypoints_np = np.array(local_waypoints)
for i in range(1, local_waypoints_np.shape[0]):
wp_distance.append(
np.sqrt((local_waypoints_np[i, 0] - local_waypoints_np[i-1, 0])**2 +
(local_waypoints_np[i, 1] - local_waypoints_np[i-1, 1])**2))
wp_distance.append(0) # last distance is 0 because it is the distance
# from the last waypoint to the last waypoint
# Linearly interpolate between waypoints and store in a list
wp_interp = [] # interpolated values
# (rows = waypoints, columns = [x, y, v])
for i in range(local_waypoints_np.shape[0] - 1):
# Add original waypoint to interpolated waypoints list (and append
# it to the hash table)
wp_interp.append(list(local_waypoints_np[i]))
# Interpolate to the next waypoint. First compute the number of
# points to interpolate based on the desired resolution and
# incrementally add interpolated points until the next waypoint
# is about to be reached.
num_pts_to_interp = int(np.floor(wp_distance[i] /\
float(INTERP_DISTANCE_RES)) - 1)
wp_vector = local_waypoints_np[i+1] - local_waypoints_np[i]
wp_uvector = wp_vector / np.linalg.norm(wp_vector[0:2])
for j in range(num_pts_to_interp):
next_wp_vector = INTERP_DISTANCE_RES * float(j+1) * wp_uvector
wp_interp.append(list(local_waypoints_np[i] + next_wp_vector))
# add last waypoint at the end
wp_interp.append(list(local_waypoints_np[-1]))
# Update the other controller values and controls
controller.update_waypoints(wp_interp)
pass
###
# Controller Update
###
if local_waypoints != None and local_waypoints != []:
controller.update_values(current_x, current_y, current_yaw,
current_speed,
current_timestamp, frame)
controller.update_controls()
cmd_throttle, cmd_steer, cmd_brake = controller.get_commands()
else:
cmd_throttle = 0.0
cmd_steer = 0.0
cmd_brake = 0.0
# Skip the first frame or if there exists no local paths
if skip_first_frame and frame == 0:
pass
elif local_waypoints == None:
pass
else:
# Update live plotter with new feedback
trajectory_fig.roll("trajectory", current_x, current_y)
trajectory_fig.roll("car", current_x, current_y)
if lead_car_pos: # If there exists a lead car, plot it
trajectory_fig.roll("leadcar", lead_car_pos[1][0],
lead_car_pos[1][1])
forward_speed_fig.roll("forward_speed",
current_timestamp,
current_speed)
forward_speed_fig.roll("reference_signal",
current_timestamp,
controller._desired_speed)
throttle_fig.roll("throttle", current_timestamp, cmd_throttle)
brake_fig.roll("brake", current_timestamp, cmd_brake)
steer_fig.roll("steer", current_timestamp, cmd_steer)
# Local path plotter update
if frame % LP_FREQUENCY_DIVISOR == 0:
path_counter = 0
for i in range(NUM_PATHS):
# If a path was invalid in the set, there is no path to plot.
if path_validity[i]:
# Colour paths according to collision checking.
if not collision_check_array[path_counter]:
colour = 'r'
elif i == best_index:
colour = 'k'
else:
colour = 'b'
trajectory_fig.update("local_path " + str(i), paths[path_counter][0], paths[path_counter][1], colour)
path_counter += 1
else:
trajectory_fig.update("local_path " + str(i), [ego_state[0]], [ego_state[1]], 'r')
# When plotting lookahead path, only plot a number of points
# (INTERP_MAX_POINTS_PLOT amount of points). This is meant
# to decrease load when live plotting
wp_interp_np = np.array(wp_interp)
path_indices = np.floor(np.linspace(0,
wp_interp_np.shape[0]-1,
INTERP_MAX_POINTS_PLOT))
trajectory_fig.update("selected_path",
wp_interp_np[path_indices.astype(int), 0],
wp_interp_np[path_indices.astype(int), 1],
new_colour=[1, 0.5, 0.0])
# Refresh the live plot based on the refresh rate
# set by the options
if enable_live_plot and \
live_plot_timer.has_exceeded_lap_period():
lp_traj.refresh()
lp_1d.refresh()
live_plot_timer.lap()
# Output controller command to CARLA server
send_control_command(client,
throttle=cmd_throttle,
steer=cmd_steer,
brake=cmd_brake)
# Find if reached the end of waypoint. If the car is within
# DIST_THRESHOLD_TO_LAST_WAYPOINT to the last waypoint,
# the simulation will end.
dist_to_last_waypoint = np.linalg.norm(np.array([
waypoints[-1][0] - current_x,
waypoints[-1][1] - current_y]))
if dist_to_last_waypoint < DIST_THRESHOLD_TO_LAST_WAYPOINT:
reached_the_end = True
if reached_the_end:
break
# End of demo - Stop vehicle and Store outputs to the controller output
# directory.
if reached_the_end:
print("Reached the end of path. Writing to controller_output...")
else:
print("Exceeded assessment time. Writing to controller_output...")
# Stop the car
send_control_command(client, throttle=0.0, steer=0.0, brake=1.0)
# Store the various outputs
store_trajectory_plot(trajectory_fig.fig, 'trajectory.png')
store_trajectory_plot(forward_speed_fig.fig, 'forward_speed.png')
store_trajectory_plot(throttle_fig.fig, 'throttle_output.png')
store_trajectory_plot(brake_fig.fig, 'brake_output.png')
store_trajectory_plot(steer_fig.fig, 'steer_output.png')
write_trajectory_file(x_history, y_history, speed_history, time_history,
collided_flag_history)
write_collisioncount_file(collided_flag_history)
def run_carla_client(args):
skip_frames = 100 # 100 # at 10 fps
number_of_episodes = args.n_episode
frames_per_episode = args.n_frame
# n_weather = 14 # weathers starts from 1
# n_player_start_spots = 152 # Town01
n_player_start_spots = 83 # Town02
weathers = number_of_episodes * [2] # CloudyNoon
start_spots = list(range(n_player_start_spots))
random.shuffle(start_spots)
assert number_of_episodes < n_player_start_spots
start_spots = start_spots[:number_of_episodes]
# weathers = list(range(number_of_episodes))
# # random.shuffle(weathers)
# weathers = [w % 14 + 1 for w in weathers]
# https://carla.readthedocs.io/en/latest/carla_settings/
# number_of_episodes = n_weather*n_player_start_spots
# frames_per_episode = args.n_frame
# weathers, start_spots = np.meshgrid(list(range(1, n_weather+1)), list(range(n_player_start_spots)))
# weathers = weathers.flatten()
# start_spots = start_spots.flatten()
if not os.path.isdir(args.out_dir):
os.makedirs(args.out_dir)
np.savetxt(join(args.out_dir, 'weathers.txt'), weathers, fmt='%d')
np.savetxt(join(args.out_dir, 'start-spots.txt'), start_spots, fmt='%d')
# We assume the CARLA server is already waiting for a client to connect at
# host:port. To create a connection we can use the `make_carla_client`
# context manager, it creates a CARLA client object and starts the
# connection. It will throw an exception if something goes wrong. The
# context manager makes sure the connection is always cleaned up on exit.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
for episode in range(number_of_episodes):
# Start a new episode.
if args.settings_filepath is None:
# Create a CarlaSettings object. This object is a wrapper around
# the CarlaSettings.ini file. Here we set the configuration we
# want for the new episode.
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=weathers[episode],
# WeatherId=random.randrange(14) + 1,
# WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel=args.quality_level)
settings.randomize_seeds()
# Now we want to add a couple of cameras to the player vehicle.
# We will collect the images produced by these cameras every
# frame.
# The default camera captures RGB images of the scene.
camera0 = Camera('RGB')
# Set image resolution in pixels.
camera0.set(FOV=args.cam_fov)
camera0.set_image_size(args.x_res, args.y_res)
# Set its position relative to the car in meters.
camera0.set_position(*args.cam_offset)
camera0.set_rotation(*args.cam_rotation)
settings.add_sensor(camera0)
# Let's add another camera producing ground-truth depth.
camera1 = Camera('Depth', PostProcessing='Depth')
camera1.set(FOV=args.cam_fov)
camera1.set_image_size(args.x_res, args.y_res)
camera1.set_position(*args.cam_offset)
camera1.set_rotation(*args.cam_rotation)
settings.add_sensor(camera1)
camera2 = Camera('SegRaw',
PostProcessing='SemanticSegmentation')
camera2.set(FOV=args.cam_fov)
camera2.set_image_size(args.x_res, args.y_res)
camera2.set_position(*args.cam_offset)
camera2.set_rotation(*args.cam_rotation)
settings.add_sensor(camera2)
if args.lidar:
lidar = Lidar('Lidar32')
lidar.set_position(0, 0, 2.50)
lidar.set_rotation(0, 0, 0)
lidar.set(Channels=32,
Range=50,
PointsPerSecond=100000,
RotationFrequency=10,
UpperFovLimit=10,
LowerFovLimit=-30)
settings.add_sensor(lidar)
else:
# Alternatively, we can load these settings from a file.
with open(args.settings_filepath, 'r') as fp:
settings = fp.read()
# Now we load these settings into the server. The server replies
# with a scene description containing the available start spots for
# the player. Here we can provide a CarlaSettings object or a
# CarlaSettings.ini file as string.
scene = client.load_settings(settings)
# Choose one player start at random.
# number_of_player_starts = len(scene.player_start_spots)
# player_start = random.randrange(number_of_player_starts)
player_start = start_spots[episode]
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print('Starting new episode...')
client.start_episode(player_start)
frame = 0
save_frame_idx = 0
# extra_frames = 0
# last_control = None
# last_control_changed = 0
# while frame < skip_frames + frames_per_episode + extra_frames:
# Iterate every frame in the episode.
for frame in range(skip_frames + frames_per_episode):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
# Print some of the measurements.
print_measurements(measurements)
# Save the images to disk if requested.
if args.save_images_to_disk and frame >= skip_frames \
and (frame - skip_frames) % args.save_every_n_frames == 0:
# if last_control_changed < frame - args.save_every_n_frames:
# extra_frames += args.save_every_n_frames
# last_control_changed += args.save_every_n_frames
# else:
save_frame_idx += 1
for name, measurement in sensor_data.items():
filename = args.out_filename_format.format(
episode + 1, name, save_frame_idx)
measurement.save_to_disk(filename)
# We can access the encoded data of a given image as numpy
# array using its "data" property. For instance, to get the
# depth value (normalized) at pixel X, Y
#
# depth_array = sensor_data['CameraDepth'].data
# value_at_pixel = depth_array[Y, X]
#
# Now we have to send the instructions to control the vehicle.
# If we are in synchronous mode the server will pause the
# simulation until we send this control.
if not args.autopilot:
client.send_control(steer=random.uniform(-1.0, 1.0),
throttle=0.5,
brake=0.0,
hand_brake=False,
reverse=False)
else:
# Together with the measurements, the server has sent the
# control that the in-game autopilot would do this frame. We
# can enable autopilot by sending back this control to the
# server. We can modify it if wanted, here for instance we
# will add some noise to the steer.
control = measurements.player_measurements.autopilot_control
# if last_control:
# for v1, v2 in zip(control.values(), last_control.values()):
# if v1 != v2:
# last_control_changed = frame
# break
control.steer += random.uniform(-0.1, 0.1)
client.send_control(control)
def run_carla_client(args):
# Here we will run 3 episodes with 300 frames each.
number_of_episodes = 60000
frames_per_episode = 400
# We assume the CARLA server is already waiting for a client to connect at
# host:port. To create a connection we can use the `make_carla_client`
# context manager, it creates a CARLA client object and starts the
# connection. It will throw an exception if something goes wrong. The
# context manager makes sure the connection is always cleaned up on exit.
with make_carla_client(args.host, args.port, 30) as client:
print('CarlaClient connected')
# =============================================================================
# Global initialisations
# =============================================================================
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
K.set_session(sess)
state_size = {
'state_2D': (
64,
64,
9,
),
'state_1D': (17, )
}
action_size = (5, )
critic = Critic(sess, state_size, action_size, CRITIC_LR)
critic.target_train()
actor = Actor(sess, state_size, action_size, ACTOR_LR)
actor.target_train()
memory = ExperienceMemory(100000, False)
target_update_counter = 0
target_update_freq = TARGET_UPDATE_BASE_FREQ
explore_rate = 0.2
success_counter = 0
total_t = 0
t = 0
#NOTE Ez csak egy próba, eztmég át kell alakítani
target = {
'pos': np.array([-3.7, 236.4, 0.9]),
'ori': np.array([0.00, -1.00, 0.00])
}
if args.settings_filepath is None:
# Create a CarlaSettings object. This object is a wrapper around
# the CarlaSettings.ini file. Here we set the configuration we
# want for the new episode.
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=0,
NumberOfPedestrians=0,
WeatherId=random.choice([1]),
QualityLevel=args.quality_level)
# settings.randomize_seeds()
#
# settings.randomize_seeds()
# The default camera captures RGB images of the scene.
camera0 = Camera('CameraRGB')
# Set image resolution in pixels.
camera0.set_image_size(64, 64)
# Set its position relative to the car in centimeters.
camera0.set_position(0.30, 0, 1.30)
settings.add_sensor(camera0)
else:
# Alternatively, we can load these settings from a file.
with open(args.settings_filepath, 'r') as fp:
settings = fp.read()
scene = client.load_settings(settings)
# =============================================================================
# EPISODES LOOP
# =============================================================================
for episode in range(0, number_of_episodes):
# Start a new episode.
# Choose one player start at random.
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0,
number_of_player_starts - 1))
player_start = 0
total_reward = 0.
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print('Starting new episode...')
client.start_episode(player_start)
#TODO Ezen belül kéne implementálni a tanuló algoritmusunkat
# =============================================================================
# Episodic intitialisations
# =============================================================================
collisions = {'car': 0, 'ped': 0, 'other': 0}
reverse = -1.0
measurements, sensor_data = client.read_data()
state = get_state_from_data(measurements, sensor_data, reverse)
goal = get_goal_from_data(target)
t = 0
stand_still_counter = 0
# =============================================================================
# STEPS LOOP
# =============================================================================
for frame in range(0, frames_per_episode):
t = t + 1
total_t += 1
target_update_counter += 1
explore_dev = 0.6 / (1 + total_t / 30000)
explore_rate = 0.3 / (1 + total_t / 30000)
# Print some of the measurements.
# print_measurements(measurements)
# Save the images to disk if requested.
if args.save_images_to_disk and False:
for name, measurement in sensor_data.items():
filename = args.out_filename_format.format(
episode, name, frame)
measurement.save_to_disk(filename)
if state['state_1D'][9] < 5 and t > 50:
stand_still_counter += 1
else:
stand_still_counter = 0
#Calculate the action
a_pred = actor.model.predict([
np.expand_dims(state['state_2D'], 0),
np.expand_dims(np.concatenate((state['state_1D'], goal)),
0)
])[0]
#Add exploration noise to action
a = add_noise(a_pred, explore_dev, explore_rate)
control = get_control_from_a(a)
#Sendcontrol to the server
client.send_control(control)
#
# =============================================================================
# TRAINING THE NETWORKS
# =============================================================================
if memory.num_items > 6000:
batch, indeces = memory.sample_experience(MINI_BATCH_SIZE)
raw_states = [[e[0]['state_2D'], e[0]['state_1D']]
for e in batch]
goals = np.asarray([e[5] for e in batch])
states = {
'state_2D':
np.atleast_2d(np.asarray([e[0]
for e in raw_states[:]])),
'state_1D':
np.atleast_2d(
np.asarray([
np.concatenate([e[1], goals[i]], axis=-1)
for i, e in enumerate(raw_states[:])
]))
}
actions = np.asarray([e[1] for e in batch])
rewards = np.asarray([np.sum(e[2])
for e in batch]).reshape(-1, 1)
raw_new_states = [[e[3]['state_2D'], e[3]['state_1D']]
for e in batch]
new_states = {
'state_2D':
np.atleast_2d(
np.asarray([e[0] for e in raw_new_states[:]])),
'state_1D':
np.atleast_2d(
np.asarray([
np.concatenate([e[1], goals[i]], axis=-1)
for i, e in enumerate(raw_new_states[:])
]))
}
overs = np.asarray([e[4] for e in batch]).reshape(-1, 1)
best_a_preds = actor.target_model.predict(
[new_states['state_2D'], new_states['state_1D']])
max_qs = critic.target_model.predict([
new_states['state_2D'], new_states['state_1D'],
best_a_preds
])
ys = rewards + (1 - overs) * GAMMA * max_qs
#Train Critic network
critic.model.train_on_batch(
[states['state_2D'], states['state_1D'], actions], ys)
#Train Actor network
a_for_grads = actor.model.predict(
[states['state_2D'], states['state_1D']])
a_grads = critic.gradients(states, a_for_grads)
actor.train(states, a_grads)
#Train target networks
if target_update_counter >= int(target_update_freq):
target_update_counter = 0
target_update_freq = target_update_freq * TARGET_UPDATE_MULTIPLIER
critic.target_train()
actor.target_train()
# =============================================================================
# GET AND STORE OBSERVATIONS
# =============================================================================
#Get next measurements
measurements, sensor_data = client.read_data()
new_state = get_state_from_data(measurements, sensor_data,
reverse, state)
#TODO Calculate reward
r_goal, success = calculate_goal_reward(
np.atleast_2d(new_state['state_1D']), goal)
r_general, collisions = calculate_general_reward(
measurements, collisions)
over = stand_still_counter > 30 or success
success_counter += int(bool(success) * 1)
total_reward += r_goal
total_reward += r_general
#Store observation
if t > 10:
experience = pd.DataFrame(
[[
state, a,
np.array([r_goal, r_general]), new_state,
bool(over), goal, episode, 0
]],
columns=['s', 'a', 'r', "s'", 'over', 'g', 'e', 'p'],
copy=True)
memory.add_experience(experience)
#Set the state to the next state
state = new_state
if over:
break
sub_goal = deepcopy(state['state_1D'][0:6])
print(str(episode) + ". Episode###################")
print("Total reward: " + str(total_reward))
print("Success counter: " + str(success_counter))
if (episode % 10 == 0):
print("############## DEBUG LOG ################")
print("Memory state: " + str(memory.num_items))
print("Target update counter: " + str(target_update_counter))
print("Exploration rate: " + str(explore_rate))
print("Exploration dev: " + str(explore_dev))
print("Total timesteps: " + str(total_t))
print("Average episode length: " + str(total_t /
(episode + 1)))
print("#########################################")
# =============================================================================
# REPLAY FOR SUBGOALS
# =============================================================================
batch = memory.get_last_episode(t)
raw_new_states = [[e[3]['state_2D'], e[3]['state_1D']]
for e in batch]
new_states = {
'state_2D':
np.atleast_2d(np.asarray([e[0] for e in raw_new_states[:]])),
'state_1D':
np.atleast_2d(np.asarray([e[1] for e in raw_new_states[:]]))
}
rewards = np.asarray([e[2] for e in batch]).reshape(-1, 2)
r_subgoal = calculate_goal_reward(new_states['state_1D'],
sub_goal)[0]
rewards[:, 0] = r_subgoal
subgoal_batch = [[
v[0], v[1],
list(rewards)[i], v[3], v[4], sub_goal, v[6], v[7]
] for i, v in enumerate(batch)]
experiences = pd.DataFrame(
subgoal_batch,
columns=['s', 'a', 'r', "s'", 'over', 'g', 'e', 'p'],
copy=True)
memory.add_experience(experiences)
def run_carla_client(host, port, autopilot_on, save_images_to_disk,
image_filename_format, settings_filepath):
# Here we will run 3 episodes with 300 frames each.
number_of_episodes = 3
frames_per_episode = 300
# We assume the CARLA server is already waiting for a client to connect at
# host:port. To create a connection we can use the `make_carla_client`
# context manager, it creates a CARLA client object and starts the
# connection. It will throw an exception if something goes wrong. The
# context manager makes sure the connection is always cleaned up on exit.
with make_carla_client(host, port) as client:
print('CarlaClient connected')
for episode in range(0, number_of_episodes):
# Start a new episode.
if settings_filepath is None:
# Create a CarlaSettings object. This object is a wrapper around
# the CarlaSettings.ini file. Here we set the configuration we
# want for the new episode.
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=random.choice([1, 3, 7, 8, 14]))
settings.randomize_seeds()
# Now we want to add a couple of cameras to the player vehicle.
# We will collect the images produced by these cameras every
# frame.
# The default camera captures RGB images of the scene.
camera0 = Camera('CameraRGB')
# Set image resolution in pixels.
camera0.set_image_size(800, 600)
# Set its position relative to the car in centimeters.
camera0.set_position(30, 0, 130)
settings.add_sensor(camera0)
# Let's add another camera producing ground-truth depth.
camera1 = Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(800, 600)
camera1.set_position(30, 0, 130)
settings.add_sensor(camera1)
else:
# Alternatively, we can load these settings from a file.
with open(settings_filepath, 'r') as fp:
settings = fp.read()
# Now we load these settings into the server. The server replies
# with a scene description containing the available start spots for
# the player. Here we can provide a CarlaSettings object or a
# CarlaSettings.ini file as string.
scene = client.load_settings(settings)
# Choose one player start at random.
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0,
number_of_player_starts - 1))
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print('Starting new episode...')
client.start_episode(player_start)
# Iterate every frame in the episode.
for frame in range(0, frames_per_episode):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
# Print some of the measurements.
print_measurements(measurements)
# Save the images to disk if requested.
if save_images_to_disk:
for name, image in sensor_data.items():
image.save_to_disk(
image_filename_format.format(episode, name, frame))
# We can access the encoded data of a given image as numpy
# array using its "data" property. For instance, to get the
# depth value (normalized) at pixel X, Y
#
# depth_array = sensor_data['CameraDepth'].data
# value_at_pixel = depth_array[Y, X]
#
# Now we have to send the instructions to control the vehicle.
# If we are in synchronous mode the server will pause the
# simulation until we send this control.
if not autopilot_on:
client.send_control(steer=random.uniform(-1.0, 1.0),
throttle=0.5,
brake=0.0,
hand_brake=False,
reverse=False)
else:
# Together with the measurements, the server has sent the
# control that the in-game autopilot would do this frame. We
# can enable autopilot by sending back this control to the
# server. We can modify it if wanted, here for instance we
# will add some noise to the steer.
control = measurements.player_measurements.autopilot_control
control.steer += random.uniform(-0.1, 0.1)
client.send_control(control)
def run_carla_client(args):
# Here we will run args._episode episodes with args._frames frames each.
number_of_episodes = args._episode
frames_per_episode = args._frames
# create the carla client
with make_carla_client(args.host, args.port, timeout=10000) as client:
print('CarlaClient connected')
for episode in range(0, number_of_episodes):
if args.settings_filepath is None:
settings = CarlaSettings()
settings.set(
SynchronousMode=args.synchronous_mode,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=200,
NumberOfPedestrians=100,
WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel=args.quality_level)
settings.randomize_seeds()
# The default camera captures RGB images of the scene.
camera0 = Camera('CameraRGB')
# Set image resolution in pixels.
camera0.set_image_size(1920, 640)
# Set its position relative to the car in meters.
camera0.set_position(2.00, 0, 1.30)
settings.add_sensor(camera0)
camera1 = Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(1920, 640)
camera1.set_position(2.00, 0, 1.30)
settings.add_sensor(camera1)
#slows down the simulation too much by processing segmentation before saving
#camera2 = Camera('CameraSegmentation', PostProcessing='SemanticSegmentation')
#camera2.set_image_size(1920, 640)
#camera2.set_position(2.00, 0, 1.30)
#settings.add_sensor(camera2)
if args.lidar:
lidar = Lidar('Lidar32')
lidar.set_position(0, 0, 2.50)
lidar.set_rotation(0, 0, 0)
lidar.set(
Channels=32,
Range=50,
PointsPerSecond=100000,
RotationFrequency=10,
UpperFovLimit=10,
LowerFovLimit=-30)
settings.add_sensor(lidar)
else:
# Alternatively, we can load these settings from a file.
with open(args.settings_filepath, 'r') as fp:
settings = fp.read()
scene = client.load_settings(settings)
# Choose one player start at random.
#if intersection flag is set start near and facing an intersection
if args.intersection_start:
text_file = open(args.intersection_file, "r")
player_intersection_start = text_file.read().split(' ')
player_start = int(player_intersection_start[random.randint(0, max(0, len(player_intersection_start) - 1))])
text_file.close()
print("Player start index="+str(player_start))
else:
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0, number_of_player_starts - 1))
print('Starting new episode at %r...' % scene.map_name)
client.start_episode(player_start)
# create folders for current episode
file_loc = args.file_loc_format.format(episode)
if not os.path.exists(file_loc):
os.makedirs(file_loc)
file_loc_tracklets = file_loc + "/tracklets/"
if not os.path.exists(file_loc_tracklets):
os.makedirs(file_loc_tracklets)
file_loc_grid = file_loc + "/gridmap/"
if not os.path.exists(file_loc_grid):
os.makedirs(file_loc_grid)
print('Data saved in %r' % file_loc)
# Iterate every frame in the episode.
for frame in range(0, frames_per_episode):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
#discard episode if misbehaviour flag is set and a form of collision is detected
if args.no_misbehaviour:
player_measurements = measurements.player_measurements
col_cars=player_measurements.collision_vehicles
col_ped=player_measurements.collision_pedestrians
col_other=player_measurements.collision_other
if col_cars + col_ped + col_other > 0:
print("MISBEHAVIOUR DETECTED! Discarding Episode... \n")
break
# Print some of the measurements.
print_measurements(measurements)
# Save the images to disk if requested. Skip first couple of images due to setup time.
if args.save_images_to_disk and frame > 19:
player_measurements = measurements.player_measurements
# process player odometry
yaw = ((player_measurements.transform.rotation.yaw - yaw_shift - 180) % 360) - 180
#calculate yaw_rate
game_time = np.int64(measurements.game_timestamp)
time_diff = (game_time - prev_time) / 1000 # ms -> sec
prev_time = game_time
if time_diff == 0:
yaw_rate = 0
else:
yaw_rate = (180 - abs(abs(yaw - yaw_old) - 180))/time_diff * np.sign(yaw-yaw_old)
yaw_old = yaw
#write odometry data to .txt
with open(file_loc+"odometry_t_mus-x_m-y_m-yaw_deg-yr_degs-v_ms.txt", "a") as text_file:
text_file.write("%d %f %f %f %f %f\n" % \
(round(args.start_time+measurements.game_timestamp),
player_measurements.transform.location.x - shift_x,
player_measurements.transform.location.y - shift_y,
-yaw,
-yaw_rate,
player_measurements.forward_speed))
# need modified saver to save converted segmentation
for name, measurement in sensor_data.items():
filename = args.out_filename_format.format(episode, name, frame)
if name == 'CameraSegmentation':
measurement.save_to_disk_converted(filename)
else:
measurement.save_to_disk(filename)
with open(file_loc_tracklets+str(round(args.start_time+measurements.game_timestamp))+".txt", "w") as text_file:
im = Image.new('L', (256*6, 256*6), (127))
shift = 256*6/2
draw = ImageDraw.Draw(im)
# create occupancy map and save participant info in tracklet txt file similar to KITTI
for agent in measurements.non_player_agents:
if agent.HasField('vehicle') or agent.HasField('pedestrian'):
participant = agent.vehicle if agent.HasField('vehicle') else agent.pedestrian
angle = cart2pol(participant.transform.orientation.x, participant.transform.orientation.y)
text_file.write("%d %f %f %f %f %f\n" % \
(agent.id,
participant.transform.location.x,
participant.transform.location.y,
angle,
participant.bounding_box.extent.x,
participant.bounding_box.extent.y))
polygon = agent2world(participant, angle)
polygon = world2player(polygon, math.radians(-yaw), player_measurements.transform)
polygon = player2image(polygon, shift, multiplier=25)
polygon = [tuple(row) for row in polygon.T]
draw.polygon(polygon, 0, 0)
im = im.resize((256,256), Image.ANTIALIAS)
im = im.rotate(imrotate)
im.save(file_loc_grid + 'gridmap_'+ str(round(args.start_time+measurements.game_timestamp)) +'_occupancy' + '.png')
else:
# get first values
yaw_shift = measurements.player_measurements.transform.rotation.yaw
yaw_old = ((yaw_shift - 180) % 360) - 180
imrotate = round(yaw_old)+90
shift_x = measurements.player_measurements.transform.location.x
shift_y = measurements.player_measurements.transform.location.y
prev_time = np.int64(measurements.game_timestamp)
if not args.autopilot:
client.send_control(
steer=random.uniform(-1.0, 1.0),
throttle=0.5,
brake=0.0,
hand_brake=False,
reverse=False)
else:
control = measurements.player_measurements.autopilot_control
control.steer += random.uniform(-0.01, 0.01)
client.send_control(control)
def main():
"""
The main function of the data collection process
"""
argparser = argparse.ArgumentParser(
description='CARLA Manual Control Client')
argparser.add_argument('-v',
'--verbose',
action='store_true',
dest='verbose',
help='print debug information')
argparser.add_argument('--host',
metavar='H',
default='localhost',
help='IP of the host server (default: localhost)')
argparser.add_argument('-p',
'--port',
metavar='P',
default=2000,
type=int,
help='TCP port to listen to (default: 2000)')
argparser.add_argument('-pt',
'--data-path',
metavar='H',
default='.',
dest='data_path',
help=' Where the recorded data will be placed')
argparser.add_argument(
'--data-configuration-name',
metavar='H',
default='coil_training_dataset_singlecamera',
dest='data_configuration_name',
help=
' Name of the data configuration file that should be place on .dataset_configurations'
)
argparser.add_argument(
'-c',
'--controlling_agent',
default='CommandFollower',
help='the controller that is going to be used by the main vehicle.'
' Options: '
' HumanAgent - Control your agent with a keyboard.'
' ForwardAgent - A trivial agent that goes forward'
' LaneFollower - An agent that follow lanes and stop obstacles'
' CommandFollower - A lane follower agent that follow commands from the planner'
)
argparser.add_argument(
'-db',
'--debug',
action='store_true',
help=
'enable the debug screen mode, on this mode a rendering screen will show'
'information about the agent')
argparser.add_argument('-dp',
'--draw-pedestrians',
dest='draw_pedestrians',
action='store_true',
help='add pedestrians to the debug screen')
argparser.add_argument('-dv',
'--draw-vehicles',
dest='draw_vehicles',
action='store_true',
help='add vehicles dots to the debug screen')
argparser.add_argument('-dt',
'--draw-traffic-lights',
dest='draw_traffic_lights',
action='store_true',
help='add traffic lights dots to the debug screen')
argparser.add_argument(
'-nr',
'--not-record',
action='store_true',
default=False,
help='flag for not recording the data ( Testing purposes)')
argparser.add_argument(
'-e',
'--episode-number',
metavar='E',
dest='episode_number',
default=0,
type=int,
help='The episode number that it will start to record.')
argparser.add_argument(
'-n',
'--number-episodes',
metavar='N',
dest='number_of_episodes',
default=999999999,
help='The number of episodes to run, default infinite.')
args = argparser.parse_args()
log_level = logging.DEBUG if args.verbose else logging.INFO
logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)
logging.info('listening to server %s:%s', args.host, args.port)
while True:
with make_carla_client(args.host, args.port) as client:
collect(client, args)
break
def run_carla_client(args):
# Here we will run 3 episodes with 300 frames each.
number_of_episodes = 3
frames_per_episode = 300
# We assume the CARLA server is already waiting for a client to connect at
# host:port. To create a connection we can use the `make_carla_client`
# context manager, it creates a CARLA client object and starts the
# connection. It will throw an exception if something goes wrong. The
# context manager makes sure the connection is always cleaned up on exit.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
for episode in range(0, number_of_episodes):
# Start a new episode.
if args.settings_filepath is None:
# Create a CarlaSettings object. This object is a wrapper around
# the CarlaSettings.ini file. Here we set the configuration we
# want for the new episode.
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel=args.quality_level)
settings.randomize_seeds()
# Now we want to add a couple of cameras to the player vehicle.
# We will collect the images produced by these cameras every
# frame.
# The default camera captures RGB images of the scene.
camera0 = Camera('CameraRGB')
# Set image resolution in pixels.
camera0.set_image_size(800, 600)
# Set its position relative to the car in meters.
camera0.set_position(0.30, 0, 1.30)
settings.add_sensor(camera0)
# Let's add another camera producing ground-truth depth.
camera1 = Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(800, 600)
camera1.set_position(0.30, 0, 1.30)
settings.add_sensor(camera1)
if args.lidar:
lidar = Lidar('Lidar32')
lidar.set_position(0, 0, 2.50)
lidar.set_rotation(0, 0, 0)
lidar.set(
Channels=32,
Range=50,
PointsPerSecond=100000,
RotationFrequency=10,
UpperFovLimit=10,
LowerFovLimit=-30)
settings.add_sensor(lidar)
else:
# Alternatively, we can load these settings from a file.
with open(args.settings_filepath, 'r') as fp:
settings = fp.read()
# Now we load these settings into the server. The server replies
# with a scene description containing the available start spots for
# the player. Here we can provide a CarlaSettings object or a
# CarlaSettings.ini file as string.
scene = client.load_settings(settings)
# Choose one player start at random.
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0, number_of_player_starts - 1))
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print('Starting new episode at %r...' % scene.map_name)
client.start_episode(player_start)
# Iterate every frame in the episode.
for frame in range(0, frames_per_episode):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
# Print some of the measurements.
print_measurements(measurements)
# Save the images to disk if requested.
if args.save_images_to_disk:
for name, measurement in sensor_data.items():
filename = args.out_filename_format.format(episode, name, frame)
measurement.save_to_disk(filename)
# We can access the encoded data of a given image as numpy
# array using its "data" property. For instance, to get the
# depth value (normalized) at pixel X, Y
#
# depth_array = sensor_data['CameraDepth'].data
# value_at_pixel = depth_array[Y, X]
#
# Now we have to send the instructions to control the vehicle.
# If we are in synchronous mode the server will pause the
# simulation until we send this control.
if not args.autopilot:
client.send_control(
steer=random.uniform(-1.0, 1.0),
throttle=0.5,
brake=0.0,
hand_brake=False,
reverse=False)
else:
# Together with the measurements, the server has sent the
# control that the in-game autopilot would do this frame. We
# can enable autopilot by sending back this control to the
# server. We can modify it if wanted, here for instance we
# will add some noise to the steer.
control = measurements.player_measurements.autopilot_control
control.steer += random.uniform(-0.1, 0.1)
client.send_control(control)
def run_carla_client(host, port, far):
# Here we will run a single episode with 300 frames.
number_of_frames = 3000
frame_step = 100 # Save one image every 100 frames
output_folder = '_out'
image_size = [800, 600]
camera_local_pos = [0.3, 0.0, 1.3] # [X, Y, Z]
camera_local_rotation = [0, 0, 0] # [pitch(Y), yaw(Z), roll(X)]
fov = 70
# Connect with the server
with make_carla_client(host, port) as client:
print('CarlaClient connected')
# Here we load the settings.
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=random.choice([1, 3, 7, 8, 14]))
settings.randomize_seeds()
camera1 = Camera('CameraDepth', PostProcessing='Depth', FOV=fov)
camera1.set_image_size(*image_size)
camera1.set_position(*camera_local_pos)
camera1.set_rotation(*camera_local_rotation)
settings.add_sensor(camera1)
camera2 = Camera('CameraRGB', PostProcessing='SceneFinal', FOV=fov)
camera2.set_image_size(*image_size)
camera2.set_position(*camera_local_pos)
camera2.set_rotation(*camera_local_rotation)
settings.add_sensor(camera2)
client.load_settings(settings)
# Start at location index id '0'
client.start_episode(0)
# Compute the camera transform matrix
camera_to_car_transform = camera2.get_unreal_transform()
# Iterate every frame in the episode except for the first one.
for frame in range(1, number_of_frames):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
# Save one image every 'frame_step' frames
if not frame % frame_step:
# Start transformations time mesure.
timer = StopWatch()
# RGB image [[[r,g,b],..[r,g,b]],..[[r,g,b],..[r,g,b]]]
image_RGB = to_rgb_array(sensor_data['CameraRGB'])
# 2d to (camera) local 3d
# We use the image_RGB to colorize each 3D point, this is optional.
# "max_depth" is used to keep only the points that are near to the
# camera, meaning 1.0 the farest points (sky)
point_cloud = depth_to_local_point_cloud(
sensor_data['CameraDepth'],
image_RGB,
max_depth=far
)
# (Camera) local 3d to world 3d.
# Get the transform from the player protobuf transformation.
world_transform = Transform(
measurements.player_measurements.transform
)
# Compute the final transformation matrix.
car_to_world_transform = world_transform * camera_to_car_transform
# Car to World transformation given the 3D points and the
# transformation matrix.
point_cloud.apply_transform(car_to_world_transform)
# End transformations time mesure.
timer.stop()
# Save PLY to disk
# This generates the PLY string with the 3D points and the RGB colors
# for each row of the file.
point_cloud.save_to_disk(os.path.join(
output_folder, '{:0>5}.ply'.format(frame))
)
print_message(timer.milliseconds(), len(point_cloud), frame)
client.send_control(
measurements.player_measurements.autopilot_control
)
def run_carla_client(args):
# Here we will run 3 episodes with 300 frames each.
number_of_episodes = 5
cut_per_episode = 40
frames_per_cut = 200
# We assume the CARLA server is already waiting for a client to connect at
# host:port. To create a connection we can use the `make_carla_client`
# context manager, it creates a CARLA client object and starts the
# connection. It will throw an exception if something goes wrong. The
# context manager makes sure the connection is always cleaned up on exit.
with make_carla_client(args.host, args.port) as client:
print('CarlaClient connected')
for episode in range(0, number_of_episodes):
print("input any key to continue...")
start = input()
# each episode dir store a set of traindata. if dir not existed, then make it
pathdir = '/home/kadn/dataTrain/episode_{:0>3}'.format(episode)
mkdir(pathdir)
# Create a CarlaSettings object. This object is a wrapper around
# the CarlaSettings.ini file. Here we set the configuration we
# want for the new episode.
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
# WeatherId=random.choice([1, 3, 7, 8, 14]),
WeatherId = 1,
QualityLevel=args.quality_level)
settings.randomize_seeds()
# Now we want to add a couple of cameras to the player vehicle.
# We will collect the images produced by these cameras every
# frame.
# The default camera captures RGB images of the scene.
camera0 = Camera('CameraRGB')
# Set image resolution in pixels.
camera0.set_image_size(88, 200)
# Set its position relative to the car in meters.
camera0.set_position(0.30, 0, 1.30)
settings.add_sensor(camera0)
# Let's add another camera producing ground-truth depth.
camera1 = Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(200, 88)
camera1.set_position(0.30, 0, 1.30)
settings.add_sensor(camera1)
camera2 = Camera('CameraSemSeg', PostProcessing='SemanticSegmentation')
camera2.set_image_size(88, 200)
camera2.set_position(2.0, 0.0, 1.4)
camera2.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera2)
# if args.lidar:
lidar = Lidar('Lidar32')
lidar.set_position(0, 0, 2.50)
lidar.set_rotation(0, 0, 0)
lidar.set(
Channels=0,
Range=30,
PointsPerSecond=200000,
RotationFrequency=10,
UpperFovLimit=0,
LowerFovLimit=0)
settings.add_sensor(lidar)
# else:
#
# # Alternatively, we can load these settings from a file.
# with open(args.settings_filepath, 'r') as fp:
# settings = fp.read()
# Now we load these settings into the server. The server replies
# with a scene description containing the available start spots for
# the player. Here we can provide a CarlaSettings object or a
# CarlaSettings.ini file as string.
scene = client.load_settings(settings)
# Choose one player start at random.
# number_of_player_starts = len(scene.player_start_spots)
# player_start = random.randint(0, max(0, number_of_player_starts - 1))
player_start = 1
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print('Starting new episode at %r...' % scene.map_name)
# Start a new episode.
client.start_episode(player_start)
for cut_per_episode in range(0,cut_per_episode):
num = fileCounter(pathdir)
filename = "data_{:0>6}.h5".format(num)
filepath = pathdir + '/' + filename
f = h5py.File(filepath, "w")
rgb_file = f.create_dataset("rgb", (200, 88, 200), np.uint8)
seg_file = f.create_dataset("seg", (200, 88, 200), np.uint8)
lidar_file = f.create_dataset('lidar',(200,200,200),np.uint8)
startendpoint = f.create_dataset('startend',(1,2),np.float32)
targets_file = f.create_dataset("targets", (200, 28), np.float32)
index_file = 0
# Iterate every frame in the episode.
for frame in range(0, frames_per_cut):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
# get data and store
sensors, targets_data = record_train_data(measurements,sensor_data)
rgb_file[:,:,index_file] = sensors['rgb']
seg_file[:,:,index_file] = sensors['seg']
lidar_file[:,:,index_file] = sensors['lidar']
targets_file[index_file,:] = targets_data
index_file += 1
# We can access the encoded data of a given image as numpy
# array using its "data" property. For instance, to get the
# depth value (normalized) at pixel X, Y
#
# depth_array = sensor_data['CameraDepth'].data
# value_at_pixel = depth_array[Y, X]
#
# Now we have to send the instructions to control the vehicle.
# If we are in synchronous mode the server will pause the
# simulation until we send this control.
if args.autopilot:
client.send_control(
steer=0,
throttle=0.8,
brake=0.0,
hand_brake=False,
reverse=False)
else:
# Together with the measurements, the server has sent the
# control that the in-game autopilot would do this frame. We
# can enable autopilot by sending back this control to the
# server. We can modify it if wanted, here for instance we
# will add some noise to the steer.
control = measurements.player_measurements.autopilot_control
control.steer += random.uniform(-0.05, 0.05)
client.send_control(control)
def run_carla_clients(args):
filename = '_images_repeatability/server{:d}/{:0>6d}.png'
with make_carla_client(args.host1, args.port1) as client1:
logging.info('1st client connected')
with make_carla_client(args.host2, args.port2) as client2:
logging.info('2nd client connected')
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=50,
NumberOfPedestrians=50,
WeatherId=random.choice([1, 3, 7, 8, 14]))
settings.randomize_seeds()
if args.images_to_disk:
camera = Camera('DefaultCamera')
camera.set_image_size(800, 600)
settings.add_sensor(camera)
scene1 = client1.load_settings(settings)
scene2 = client2.load_settings(settings)
number_of_player_starts = len(scene1.player_start_spots)
assert number_of_player_starts == len(scene2.player_start_spots)
player_start = random.randint(0, max(0, number_of_player_starts - 1))
logging.info(
'start episode at %d/%d player start (run forever, press ctrl+c to cancel)',
player_start,
number_of_player_starts)
client1.start_episode(player_start)
client2.start_episode(player_start)
frame = 0
while True:
frame += 1
meas1, sensor_data1 = client1.read_data()
meas2, sensor_data2 = client2.read_data()
player1 = meas1.player_measurements
player2 = meas2.player_measurements
images1 = [x for x in sensor_data1.values() if isinstance(x, Image)]
images2 = [x for x in sensor_data2.values() if isinstance(x, Image)]
control1 = player1.autopilot_control
control2 = player2.autopilot_control
try:
assert len(images1) == len(images2)
assert len(meas1.non_player_agents) == len(meas2.non_player_agents)
assert player1.transform.location.x == player2.transform.location.x
assert player1.transform.location.y == player2.transform.location.y
assert player1.transform.location.z == player2.transform.location.z
assert control1.steer == control2.steer
assert control1.throttle == control2.throttle
assert control1.brake == control2.brake
assert control1.hand_brake == control2.hand_brake
assert control1.reverse == control2.reverse
except AssertionError:
logging.exception('assertion failed')
if args.images_to_disk:
assert len(images1) == 1
images1[0].save_to_disk(filename.format(1, frame))
images2[0].save_to_disk(filename.format(2, frame))
client1.send_control(control1)
client2.send_control(control2)
def run_carla_client(host, port, autopilot_on, save_images_to_disk, image_filename_format):
# Here we will run 3 episodes with 300 frames each.
number_of_episodes = 3
frames_per_episode = 300
# We assume the CARLA server is already waiting for a client to connect at
# host:port. To create a connection we can use the `make_carla_client`
# context manager, it creates a CARLA client object and starts the
# connection. It will throw an exception if something goes wrong. The
# context manager makes sure the connection is always cleaned up on exit.
with make_carla_client(host, port) as client:
print('CarlaClient connected')
for episode in range(0, number_of_episodes):
# Start a new episode.
# Create a CarlaSettings object. This object is a handy wrapper
# around the CarlaSettings.ini file. Here we set the configuration
# we want for the new episode.
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
NumberOfVehicles=30,
NumberOfPedestrians=50,
WeatherId=random.choice([1, 3, 7, 8, 14]))
settings.randomize_seeds()
# Now we want to add a couple of cameras to the player vehicle. We
# will collect the images produced by these cameras every frame.
# The default camera captures RGB images of the scene.
camera0 = Camera('CameraRGB')
# Set image resolution in pixels.
camera0.set_image_size(800, 600)
# Set its position relative to the car in centimeters.
camera0.set_position(30, 0, 130)
settings.add_camera(camera0)
# Let's add another camera producing ground-truth depth.
camera1 = Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(800, 600)
camera1.set_position(30, 0, 130)
settings.add_camera(camera1)
print('Requesting new episode...')
# Now we request a new episode with these settings. The server
# replies with a scene description containing the available start
# spots for the player. Here instead of a CarlaSettings object we
# could also provide a CarlaSettings.ini file as string.
scene = client.request_new_episode(settings)
# Choose one player start at random.
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0, number_of_player_starts - 1))
# Notify the server that we want to start the episode at
# `player_start`. This function blocks until the server is ready to
# start the episode.
client.start_episode(player_start)
# Iterate every frame in the episode.
for frame in range(0, frames_per_episode):
# Read the measurements and images produced by the server this
# frame.
measurements, images = client.read_measurements()
# Print some of the measurements we received.
print_player_measurements(measurements.player_measurements)
# Save the images to disk if requested.
if save_images_to_disk:
for n, image in enumerate(images):
image.save_to_disk(image_filename_format.format(episode, n, frame))
# Now we have to send the instructions to control the vehicle.
# If we are in synchronous mode the server will pause the
# simulation until we send this control.
if not autopilot_on:
client.send_control(
steer=random.uniform(-1.0, 1.0),
throttle=0.3,
brake=False,
hand_brake=False,
reverse=False)
else:
# Together with the measurements, the server has sent the
# control that the in-game AI would do this frame. We can
# enable autopilot by sending back this control to the
# server. Here we will also add some noise to the steer.
control = measurements.player_measurements.ai_control
control.steer += random.uniform(-0.1, 0.1)
client.send_control(control)
print('Done.')
return True
