def main3():
global sample_count, path_to_trainingdir
# Convert training dataframe into images and labels arrays
# Training data generator with random shear and random brightness
start_time = time.time()
# Start of MODEL Definition
m = Model()
model = m.define_model()
generator = DatasetGenerator([0, 1, 2],
batch_size=10000,
dim=(32, 32, 32),
n_channels=1,
feature="steering",
shuffle=False)
model.fit_generator(generator,
steps_per_epoch=None,
epochs=1,
verbose=1,
callbacks=None,
validation_data=None,
validation_steps=None,
validation_freq=1,
class_weight=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
shuffle=False,
initial_epoch=0)
model_name = 'BeamNGmodel-racetracksteering2'
model.save_weights('{}.h5'.format(model_name))
with open('{}.json'.format(model_name), 'w') as outfile:
json.dump(model.to_json(), outfile)
print("All done :)")
print("Time to train: {}".format(time.time() - start_time))
def main2():
global sample_count, path_to_trainingdir
# Convert training dataframe into images and labels arrays
# Training data generator with random shear and random brightness
start_time = time.time()
# Start of MODEL Definition
m = Model()
model = m.define_model()
# prep training set
t = os.listdir(path_to_trainingdir)
training_dirs = [
"{}/{}/".format(path_to_trainingdir, training_dir)
for training_dir in t
]
# for training_dir in t:
# training_dirs.append("{}/{}/".format(path_to_trainingdir, training_dir))
shape = (0, 1, m.input_shape[0], m.input_shape[1], m.input_shape[2])
X_train = np.array([]).reshape(shape)
y_train = np.array([])
for d in training_dirs[-1:]:
print("Processing {}".format(d))
redo_csv("{}/data.csv".format(d))
x_temp, steering_y_temp, throttle_y_temp = process_training_dir(d, m)
print("Concatenating X_train shape:{} x_temp shape:{}".format(
X_train.shape, x_temp.shape))
X_train = np.concatenate((X_train, x_temp), axis=0)
steering_y_train = np.concatenate((y_train, steering_y_temp), axis=0)
throttle_y_train = np.concatenate((y_train, throttle_y_temp), axis=0)
print("Final X_train shape:{} Final y_train shape:{}".format(
X_train.shape, steering_y_train.shape))
# Train and save the model
BATCH_SIZE = 100
NB_EPOCH = 9
NB_SAMPLES = 2 * len(X_train)
# Train steering
model.fit(x=X_train,
y=steering_y_train,
batch_size=BATCH_SIZE,
epochs=NB_EPOCH)
model_name = 'BeamNGmodel-racetracksteering'
model.save_weights('{}.h5'.format(model_name))
with open('{}.json'.format(model_name), 'w') as outfile:
json.dump(model.to_json(), outfile)
# Train throttle
model.fit(x=X_train,
y=throttle_y_train,
batch_size=BATCH_SIZE,
epochs=NB_EPOCH)
model_name = 'BeamNGmodel-racetrackthrottle'
model.save_weights('{}.h5'.format(model_name))
with open('{}.json'.format(model_name), 'w') as outfile:
json.dump(model.to_json(), outfile)
print("All done :)")
print("Total training samples: {}".format(sample_count))
print("Time to train: {}".format(time.time() - start_time))
def main_compare_dual_model():
global sample_count, path_to_trainingdir
# Convert training dataframe into images and labels arrays
# Training data generator with random shear and random brightness
start_time = time.time()
# Start of MODEL Definition
m1 = Model()
m2 = Model()
m3 = Model()
model1 = m1.define_model()
model2 = m2.define_model()
model3 = m3.define_dual_model_BeamNG()
dirlist = [0, 1, 2]
generator = DatasetGenerator(dirlist,
batch_size=10000,
dim=(32, 32, 32),
n_channels=1,
feature="steering",
shuffle=False)
# 2D output
X, y_all, y_steering, y_throttle = generator.process_all_training_dirs_with_2D_output(
m1)
print("dataset size: {} output size: {}".format(X.shape, y_all.shape))
print("time to load dataset: {}".format(time.time() - start_time))
BATCH_SIZE = 64
NB_EPOCH = 20
# Train steering
it = "comparison10K"
model1_name = 'BeamNGmodel-racetracksteering{}'.format(it)
model2_name = 'BeamNGmodel-racetrackthrottle{}'.format(it)
model3_name = 'BeamNGmodel-racetrackdual{}'.format(it)
model1.fit(x=X, y=y_steering, batch_size=BATCH_SIZE, epochs=NB_EPOCH)
save_model(model1, model1_name)
print("Finished steering model")
# delete the previous model so that you don't max out the memory
del model1
model2.fit(x=X, y=y_throttle, batch_size=BATCH_SIZE, epochs=NB_EPOCH)
save_model(model2, model2_name)
print("Finished throttle model")
del model2
model3.fit(x=X, y=y_all, batch_size=BATCH_SIZE, epochs=NB_EPOCH)
save_model(model3, model3_name)
print("Finished dual model")
print("All done :)")
print("Time to train: {}".format(time.time() - start_time))
def data_generation(self, i):
'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)
# Initialization
X = np.empty((self.batch_size, *self.dim, self.n_channels))
y = np.empty((self.batch_size), dtype=int)
# Generate data
# for i, ID in enumerate(list_IDs_temp):
# # Store sample
# X[i,] = np.load('data/' + ID + '.npy')
#
# # Store class
# y[i] = self.labels[ID]
# 'H:/BeamNG_DAVE2_racetracks/'
training_dir = "{}training_images_industrial-racetrackstartinggate{}".format(
self.training_dir, i)
m = Model()
X, y1, y2 = self.process_training_dir(training_dir, m)
print(X.shape, y1.shape)
return X, y1, y2
def run_scenario(self):
global base_filename, default_model, default_color, default_scenario, setpoint
global prev_error
#vehicle_loadfile = 'vehicles/pickup/pristine.save.json'
# setup DNN model + weights
m = Model()
model = m.define_model_BeamNG("BeamNGmodel-4.h5")
random.seed(1703)
setup_logging()
#beamng = BeamNGpy('localhost', 64256, home='C:/Users/merie/Documents/BeamNG.research.v1.7.0.1')
beamng = BeamNGpy('localhost', 64256, home='H:/BeamNG.research.v1.7.0.1clean')
scenario = Scenario(default_scenario, 'research_test')
vehicle = Vehicle('ego_vehicle', model=default_model,
licence='LOWPRESS', color=default_color)
vehicle = setup_sensors(vehicle)
spawn = spawn_point(default_scenario, 'highway')
scenario.add_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat'])
# Compile the scenario and place it in BeamNG's map folder
scenario.make(beamng)
# Start BeamNG and enter the main loop
bng = beamng.open(launch=True)
bng.hide_hud()
bng.set_deterministic() # Set simulator to be deterministic
bng.set_steps_per_second(100) # With 60hz temporal resolution
# Load and start the scenario
bng.load_scenario(scenario)
bng.start_scenario()
# perturb vehicle
#vehicle.ai_set_mode('span')
#vehicle.ai_drive_in_lane(True)
#vehicle_loadfile = 'vehicles/etk800/fronttires_0psi.pc'
# vehicle_loadfile = 'vehicles/etk800/backtires_0psi.pc'
# vehicle_loadfile = 'vehicles/etk800/chassis_forcefeedback201.pc'
# vehicle.load_pc(vehicle_loadfile, False)
vehicle.deflate_tires([1,1,1,1])
#vehicle.break_all_breakgroups()
#vehicle.break_hinges()
# Put simulator in pause awaiting further inputs
bng.pause()
assert vehicle.skt
bng.resume()
wheelspeed = 0.0; throttle = 0.0; prev_error = setpoint; damage_prev = None; runtime = 0.0
kphs = []
damage = None
final_img = None
# Send random inputs to vehice and advance the simulation 20 steps
for _ in range(1024):
# collect images
image = bng.poll_sensors(vehicle)['front_cam']['colour'].convert('RGB')
img = m.process_image(image)
prediction = model.predict(img)
# control params
kph = ms_to_kph(wheelspeed)
throttle = throttle_PID(kph, dt)
brake = 0
#if throttle < 0:
if setpoint < kph:
brake = throttle / 1000.0
throttle = 0.0
# throttle = 0.2 # random.uniform(0.0, 1.0)
# brake = random.choice([0, 0, 0.1 , 0.2])
steering = float(prediction[0][0]) #random.uniform(-1.0, 1.0)
vehicle.control(throttle=throttle, steering=steering, brake=brake)
steering_state = bng.poll_sensors(vehicle)['electrics']['steering']
steering_input = bng.poll_sensors(vehicle)['electrics']['steering_input']
avg_wheel_av = bng.poll_sensors(vehicle)['electrics']['avg_wheel_av']
wheelspeed = bng.poll_sensors(vehicle)['electrics']['wheelspeed']
damage = bng.poll_sensors(vehicle)['damage']
new_damage = diff_damage(damage, damage_prev)
damage_prev = damage
print("\n")
# #print("steering state: {}".format(steering_state))
# print("AI steering_input: {}".format(steering_input))
#print("avg_wheel_av: {}".format(avg_wheel_av))
# print("DAVE2 steering prediction: {}".format(float(prediction[0][0])))
print("throttle:{}".format(throttle))
print("brake:{}".format(brake))
print("kph: {}".format(ms_to_kph(wheelspeed)))
print("new_damage:{}".format(new_damage))
kphs.append(ms_to_kph(wheelspeed))
if new_damage > 0.0:
final_img = image
break
bng.step(5)
runtime += (0.05)
# print("runtime:{}".format(round(runtime, 2)))
# print("time to crash:{}".format(round(runtime, 2)))
bng.close()
avg_kph = float(sum(kphs)) / len(kphs)
plt.imshow(final_img)
plt.pause(0.01)
return runtime, avg_kph, damage['damage'], kphs
def run_spawn_for_parts_config(
vehicle_model='etk800',
loadfile='C:/Users/merie/Documents/BeamNG.research/vehicles/hopper/front17x8rear17x9.json'
):
global base_filename, default_color, default_scenario, setpoint
global prev_error
global fcam
# setup DNN model + weights
m = Model()
model = m.define_model_BeamNG("BeamNGmodel-5.h5")
random.seed(1703)
setup_logging()
beamng = BeamNGpy('localhost',
64256,
home='H:/BeamNG.research.v1.7.0.1clean')
scenario = Scenario(default_scenario, 'research_test')
vehicle = Vehicle('ego_vehicle',
model=vehicle_model,
licence='LOWPRESS',
color=default_color)
vehicle = setup_sensors(vehicle)
spawn = spawn_point(default_scenario, 'highway')
# scenario.add_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat'])
# Compile the scenario and place it in BeamNG's map folder
scenario.make(beamng)
# Start BeamNG and enter the main loop
bng = beamng.open(launch=True)
# bng.hide_hud()
bng.set_deterministic() # Set simulator to be deterministic
bng.set_steps_per_second(100) # With 60hz temporal resolution
# Load and start the scenario
bng.load_scenario(scenario)
bng.start_scenario()
# vehicle.load('C:/Users/merie/Documents/BeamNG.research/vehicles/hopper/pristine.json')
if loadfile:
bng.spawn_vehicle(vehicle,
pos=spawn['pos'],
rot=None,
rot_quat=spawn['rot_quat'],
partConfig=loadfile)
else:
bng.spawn_vehicle(vehicle,
pos=spawn['pos'],
rot=None,
rot_quat=spawn['rot_quat'],
partConfig='vehicles/hopper/custom.pc')
#bng.set_relative_camera()
# Put simulator in pause awaiting further inputs
bng.pause()
assert vehicle.skt
bng.resume()
bng.set_steps_per_second(100)
bng.set_deterministic()
totalsecs = 0.0
pitch_traj = []
while totalsecs <= 30:
vehicle.update_vehicle()
camera_state = bng.poll_sensors(vehicle)['front_cam']
camera_state['roll'] = vehicle.state['roll']
camera_state['pitch'] = vehicle.state['pitch']
camera_state['yaw'] = vehicle.state['yaw']
pitch_traj.append(round(math.degrees(vehicle.state['pitch'][0]), 4))
print("roll:{}, pitch:{}, yaw:{}".format(vehicle.state['roll'],
vehicle.state['pitch'],
vehicle.state['yaw']))
bng.step(100)
totalsecs += 1
# print("Camera state:{}".format(camera_state))
image = bng.poll_sensors(vehicle)['front_cam']['colour'].convert('RGB')
#get_camera_rot_and_pos([-0.3, 1, 1.0], [0, 0.75, 0], before_state['pos'], before_state['dir'], before_state['up'])
img = m.process_image(image)
before_prediction = model.predict(img)
camera_state["prediction"] = before_prediction
plt.imshow(image)
plt.pause(0.01)
bng.close()
return camera_state, vehicle.state, pitch_traj
def run_spawn_for_deflation(vehicle_model='etk800',
deflation_pattern=[0, 0, 0, 0]):
global base_filename, default_color, default_scenario, setpoint
global prev_error
global fcam
vehicle_loadfile = 'vehicles/hopper/crawler.pc'
# setup DNN model + weights
m = Model()
model = m.define_model_BeamNG("BeamNGmodel-5.h5")
random.seed(1703)
setup_logging()
# beamng = BeamNGpy('localhost', 64256, home='C:/Users/merie/Documents/BeamNG.research.v1.7.0.1')
beamng = BeamNGpy('localhost',
64256,
home='H:/BeamNG.research.v1.7.0.1clean')
scenario = Scenario(default_scenario, 'research_test')
vehicle = Vehicle('ego_vehicle',
model=vehicle_model,
licence='LOWPRESS',
color=default_color)
vehicle = setup_sensors(vehicle)
spawn = spawn_point(default_scenario, 'highway')
# scenario.add_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat'])
# Compile the scenario and place it in BeamNG's map folder
scenario.make(beamng)
# Start BeamNG and enter the main loop
bng = beamng.open(launch=True)
# bng.hide_hud()
bng.set_deterministic() # Set simulator to be deterministic
# Load and start the scenario
bng.load_scenario(scenario)
bng.start_scenario()
# load part config
#pc = vehicle.get_part_config()
# loadfile = 'C:/Users/merie/Documents/BeamNG.research/vehicles/hopper/front17x8rear17x9.json'
# vehicle.load(loadfile)
bng.spawn_vehicle(vehicle,
pos=spawn['pos'],
rot=None,
rot_quat=spawn['rot_quat'],
partConfig='vehicles/hopper/custom.pc')
#bng.set_relative_camera()
# Put simulator in pause awaiting further inputs
bng.pause()
assert vehicle.skt
# vehicle.control(throttle=0.0, steering=0.0, brake=1.0)
# perturb vehicle
# before_state = copy.deepcopy(vehicle.state)
before_state = bng.poll_sensors(vehicle)['front_cam']
before_state['vel'] = vehicle.state['vel']
before_state['roll'] = vehicle.state['roll']
before_state['pitch'] = vehicle.state['pitch']
before_state['yaw'] = vehicle.state['yaw']
# print("vehicle position before deflation via beamstate:{}".format(vehicle.get_object_position()))
# print("vehicle position before deflation via vehicle state:{}".format(vehicle.state))
print(
"vehicle position before deflation via camera:{}".format(before_state))
image = bng.poll_sensors(vehicle)['front_cam']['colour'].convert('RGB')
# print("camera sensor before deflation: {}".format(bng.poll_sensors(vehicle)['front_cam']))
#get_camera_rot_and_pos([-0.3, 1, 1.0], [0, 0.75, 0], before_state['pos'], before_state['dir'], before_state['up'])
img = m.process_image(image)
before_prediction = model.predict(img)
before_state["prediction"] = before_prediction
plt.imshow(image)
plt.pause(0.01)
if deflation_pattern != [0, 0, 0, 0]:
print("deflating according to pattern {}".format(deflation_pattern))
vehicle.deflate_tires(deflation_pattern)
time.sleep(1)
bng.resume()
bng.set_steps_per_second(100)
bng.set_deterministic()
totalsecs = 0.0
deflation_traj = []
while totalsecs <= 30:
vehicle.update_vehicle()
# vehicle.control(throttle=0.0, steering=0.0, brake=1.0)
after_state = bng.poll_sensors(vehicle)['front_cam']
after_state['vel'] = vehicle.state['vel']
after_state['roll'] = vehicle.state['roll']
after_state['pitch'] = vehicle.state['pitch']
after_state['yaw'] = vehicle.state['yaw']
print("roll:{}, pitch:{}, yaw:{}".format(vehicle.state['roll'],
vehicle.state['pitch'],
vehicle.state['yaw']))
deflation_traj.append(round(math.degrees(vehicle.state['pitch'][0]),
4))
bng.step(100)
totalsecs += 1
# after_state = copy.deepcopy(vehicle.state)
# print("vehicle position after deflation via beamstate:{}".format(vehicle.get_object_position()))
# print("vehicle position after deflation via vehicle state:{}".format(vehicle.state))
image = bng.poll_sensors(vehicle)['front_cam']['colour'].convert('RGB')
print("vehicle position after deflation via camera:{}".format(after_state))
#print("camera sensor output: {}".format(bng.poll_sensors(vehicle)['front_cam']['rot']))
#print("camera pos output: {}".format(bng.poll_sensors(vehicle)['front_cam']['pos']))
# print("camera rot output: {}".format(bng.poll_sensors(vehicle)['front_cam']['direction']))
# print("fcam.encode_engine_request() = {}".format(fcam.encode_engine_request()))
damages = bng.poll_sensors(vehicle)['damage']['deform_group_damage']
d = ["{}={}".format(k, damages[k]['damage']) for k in damages.keys()]
print("vehicle pressure after deflation: lowpressure={} damages:".format(
bng.poll_sensors(vehicle)['damage']['lowpressure'], d))
img = m.process_image(image)
after_state["prediction"] = model.predict(img)
plt.imshow(image)
plt.pause(0.01)
bng.close()
return before_state, after_state, deflation_traj
def main():
global sample_count, path_to_trainingdir
# Convert training dataframe into images and labels arrays
# Training data generator with random shear and random brightness
start_time = time.time()
# Start of MODEL Definition
m1 = Model()
m2 = Model()
model1 = m1.define_model()
model2 = m2.define_model()
dirlist = [0, 1, 2]
generator = DatasetGenerator(dirlist,
batch_size=10000,
dim=(32, 32, 32),
n_channels=1,
feature="steering",
shuffle=False)
# model.fit_generator(generator, steps_per_epoch=None, epochs=1, verbose=1,
# callbacks=None, validation_data=None, validation_steps=None,
# validation_freq=1, class_weight=None, max_queue_size=10,
# workers=1, use_multiprocessing=False, shuffle=False, initial_epoch=0)
# for d in dirlist:
# print("Batch training on dir {}".format(d))
# X,y1, y2 = generator.data_generation(d)
# model1.train_on_batch(X, y1)
# model2.train_on_batch(X, y2)
filename_root = "H:/BeamNG_DAVE2_racetracks/training_images_industrial-racetrackstartinggate"
# X, y_steering, y_throttle = generator.process_enumerated_training_dirs(filename_root, dirlist, m1)
# 1D output
X, y_steering, y_throttle = generator.process_all_training_dirs(m1)
print("X .shape", X.shape, "y_steering.shape", y_steering.shape,
"y_throttle.shape", y_throttle.shape)
characterize_steering_distribution(y_steering, generator)
print("Moments of steering distribution:",
generator.get_distribution_moments(y_steering))
print("Moments of throttle distribution:",
generator.get_distribution_moments(y_throttle))
# 2D output
# X, y = generator.process_all_training_dirs_with_2D_output(m1)
print("time to load dataset: {}".format(time.time() - start_time))
BATCH_SIZE = 64
NB_EPOCH = 20
# Train steering
it = "1Doutput"
model1_name = 'BeamNGmodel-racetracksteering{}'.format(it)
model2_name = 'BeamNGmodel-racetrackthrottle{}'.format(it)
model1.fit(x=X, y=y_steering, batch_size=BATCH_SIZE, epochs=NB_EPOCH)
save_model(model1, model1_name)
print("Finished steering model")
# delete the previous model so that you don't max out the memory
del model1
del y_steering
model2.fit(x=X, y=y_throttle, batch_size=BATCH_SIZE, epochs=NB_EPOCH)
save_model(model2, model2_name)
print("Finished throttle model")
print("All done :)")
print("Time to train: {}".format(time.time() - start_time))
def run_comparison(vehicle_model='etk800',
deflation_pattern=[0, 0, 0, 0],
parts_config=None):
global base_filename, default_color, default_scenario, default_spawnpoint, setpoint, steps_per_sec
global integral, prev_error
integral = 0.0
prev_error = 0.0
# setup DNN model + weights
m = Model()
model = m.define_model_BeamNG("BeamNGmodel-racetrack.h5")
random.seed(1703)
setup_logging()
beamng = BeamNGpy('localhost',
64256,
home='H:/BeamNG.research.v1.7.0.1clean',
user='******')
scenario = Scenario(default_scenario, 'research_test')
# unperturbed_vehicle = Vehicle('unperturbed_vehicle', model=vehicle_model,
# licence='SAFE', color='Red')
# unperturbed_vehicle = setup_sensors(unperturbed_vehicle)
vehicle = Vehicle('ego_vehicle',
model=vehicle_model,
licence='EGO',
color=default_color)
vehicle = setup_sensors(vehicle)
spawn = get_spawn_point(default_scenario, default_spawnpoint)
scenario.add_vehicle(vehicle,
pos=spawn['pos'],
rot=None,
rot_quat=spawn['rot_quat'])
temp = copy.deepcopy(spawn['pos'])
temp = [temp[0] + lanewidth, temp[1] + lanewidth, temp[2]]
# scenario.add_vehicle(unperturbed_vehicle, pos=temp, rot=None, rot_quat=spawn['rot_quat'])
# Compile the scenario and place it in BeamNG's map folder
scenario.make(beamng)
bng = beamng.open(launch=True)
#bng.hide_hud()
bng.set_deterministic() # Set simulator to be deterministic
bng.set_steps_per_second(steps_per_sec)
# Load and start the scenario
bng.load_scenario(scenario)
bng.start_scenario()
#bng.spawn_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat'], partConfig=parts_config)
# Put simulator in pause awaiting further inputs
bng.pause()
assert vehicle.skt
bng.resume()
# perturb vehicle
vehicle.deflate_tires(deflation_pattern)
bng.step(steps_per_sec * 6)
vehicle.update_vehicle()
return_str = '\nPERTURBED headlight_cam INFO:'
print('\nPERTURBED headlight_cam INFO:')
temp = bng.poll_sensors(vehicle)['headlight_cam']
for key in temp:
if key == 'rotation':
degs = euler_from_quaternion(temp[key][0], temp[key][1],
temp[key][2], temp[key][3])
return_str = "{}\nquaternions {}".format(return_str, temp[key])
return_str = "{}\n{} {}".format(return_str, key,
[round(i, 3) for i in degs])
print(key, degs)
elif key != "colour" and key != "annotation" and key != "depth":
return_str = "{}\n{} {}".format(return_str, key, temp[key])
print(key, temp[key])
print('\nPERTURBED rearview_cam INFO:')
return_str = "{}\nPERTURBED rearview_cam INFO:".format(return_str)
# temp = bng.poll_sensors(vehicle)['rearview_cam']
for key in temp:
if key == 'rotation':
degs = euler_from_quaternion(temp[key][0], temp[key][1],
temp[key][2], temp[key][3])
return_str = "{}\nquaternions {}".format(return_str, temp[key])
return_str = "{}\n{} {}".format(return_str, key,
[round(i, 3) for i in degs])
print(key, degs)
elif key != "colour" and key != "annotation" and key != "depth":
return_str = "{}\n{} {}".format(return_str, key, temp[key])
print(key, temp[key])
# rearview_img = bng.poll_sensors(vehicle)['rearview_cam']['colour'].convert('RGB')
headlight_img = bng.poll_sensors(
vehicle)['headlight_cam']['colour'].convert('RGB')
bng.step(steps_per_sec * 6)
# print("runtime:{}".format(round(runtime, 2)))
# print("time to crash:{}".format(round(runtime, 2)))
bng.close()
# avg_kph = float(sum(kphs)) / len(kphs)
# plt.imshow(rearview_img)
# plt.pause(0.01)
plt.imshow(headlight_img)
plt.pause(0.01)
# results = {'pitch': round(pitch,3), 'roll':round(roll,3), "z":round(z,3), 'rearview_img':rearview_img, 'headlight_img':headlight_img}
return return_str