def _get_joystick_control(self,joystick):
control = VehicleControl()
tmp1 = 0.6 * joystick.get_axis(1)
if (tmp1 <= 0):
control.throttle = -tmp1
control.brake = 0
else:
control.throttle = 0
control.brake = tmp1
control.steer = joystick.get_axis(2)
control.steer = 0.5 * control.steer * control.steer * control.steer
# print('steer....',control.steer)
#provide a stable autopilot
autopilot = joystick.get_button(0)
if autopilot == 1:
self._enable_autopilot = not self._enable_autopilot
# provide a stable reverse
reverse = joystick.get_button(2)
if reverse == 1:
self._is_on_reverse = not self._is_on_reverse
control.reverse = self._is_on_reverse
return control
def _get_joystick_control(self, joystick):
control = VehicleControl()
tmp1 = 0.6 * joystick.get_axis(1)
if (tmp1 <= 0):
control.throttle = -tmp1
control.brake = 0
else:
control.throttle = 0
control.brake = tmp1
control.steer = joystick.get_axis(2)
control.steer = 0.5 * control.steer * control.steer * control.steer
# print('steer....',control.steer)
#provide a stable autopilot
autopilot = joystick.get_button(0)
if autopilot == 1:
self._enable_autopilot = not self._enable_autopilot
# provide a stable reverse
reverse = joystick.get_button(2)
if reverse == 1:
self._is_on_reverse = not self._is_on_reverse
control.reverse = self._is_on_reverse
return control
def accelerate(self):
control = VehicleControl()
control.throttle = 1.0
if (self.too_close_to('vehicle', self.vehicle_distance_threshold)):
control.throttle = self.measurements.player_measurements.autopilot_control.throttle
control.reverse = self._is_on_reverse
self.client.send_control(control)
def decode_control(self, cod):
control = VehicleControl()
control.steer = 0
control.throttle = 0
control.brake = 0
control.hand_brake = False
control.reverse = False
if cod > 9:
control.hand_brake = True
if cod == 10:
control.steer = -1
elif cod == 10:
control.steer = -1
return control
if cod == 9:
control.reverse = True
control.throttle = 1
return control
if cod % 3 == 1:
control.brake = 1
elif cod % 3 == 2:
control.throttle = 1
if cod // 3 == 1:
control.steer = 1
elif cod // 3 == 2:
control.steer = -1
return control
def _get_keyboard_control(self, keys, args):
"""
Return a VehicleControl message based on the pressed keys. Return None
if a new episode was requested.
"""
global flg_warning
if keys[K_r]:
return None
control = VehicleControl()
if keys[K_LEFT] or keys[K_a]:
control.steer = -1.0
if keys[K_RIGHT] or keys[K_d]:
control.steer = 1.0
if keys[K_UP] or keys[K_w]:
control.throttle = 1.0
if keys[K_DOWN] or keys[K_s]:
control.brake = 1.0
if keys[K_SPACE]:
control.hand_brake = True
if keys[K_q]:
self._is_on_reverse = not self._is_on_reverse
if keys[K_p]:
self._enable_autopilot = not self._enable_autopilot
if args.app == 'Control':
if flg_warning == -1:
control.throttle = 0.0
control.reverse = self._is_on_reverse
return control
def run_step(self, measurements, sensor_data, directions, target, frame):
actions = [-1.0, -0.5, 0, 0.5, 1, 0, 0.5, 1.0]
control = VehicleControl()
if frame < 30:
control.throttle = 0
else:
control.throttle = 0.6
return control
def _get_keyboard_control(self, keys):
"""
Return a VehicleControl message based on the pressed keys. Return None
if a new episode was requested.
"""
if keys[K_r]:
return None
control = VehicleControl()
self.resetVal()
################################################### YOU CAN EDIT IT ACCORDING YOU....
if keys[K_LEFT] or keys[K_a]:
self._val1 = -1
print("Left")
if (pid.prev > 0):
pid.prev = 0
elif keys[K_RIGHT] or keys[K_d]:
self._val1 = 1
print("Right")
if (pid.prev < 0):
pid.prev = 0
pid.prev += self._val1
output = pid.kp * self._val1 + pid.ki * pid.prev
print(output)
control.steer = output #Imp Line
if keys[K_UP] or keys[K_w]:
self._val2 = 1
pid.prev = 0
elif keys[K_DOWN] or keys[K_s]:
control.brake = 1
pid.prev = 0
###
if (self._velocity < 77):
control.throttle = self._val2 #Imp Line
else:
control.throttle = self._val2 * 0.8
if keys[K_SPACE]:
control.hand_brake = True
pid.prev = 0
if keys[K_f]:
self._val3 = 1 - self._val3
if keys[K_q]:
self._is_on_reverse = not self._is_on_reverse
pid.prev = 0
if keys[K_p]:
self._enable_autopilot = not self._enable_autopilot
control.reverse = self._is_on_reverse
################################################################################
#print(control)
return control
def _get_joystick_control(self):
control = VehicleControl()
control.steer = self._joystick.get_axis(0)
control.throttle = max(self._joystick.get_axis(1) * -1, 0)
control.brake = max(self._joystick.get_axis(1), 0)
return control
def steer_right(self): control = VehicleControl() control.steer = min(control.steer + 0.01, 0.05) print(control.steer) control.reverse = self._is_on_reverse control.throttle = self.measurements.player_measurements.autopilot_control.throttle self.client.send_control(control)
def action_joystick(self):
# joystick
steering_axis = self.joystick.get_axis(0)
acc_axis = self.joystick.get_axis(2)
brake_axis = self.joystick.get_axis(5)
# print("axis 0 %f, axis 2 %f, axis 3 %f" % (steering_axis, acc_axis, brake_axis))
if (self.joystick.get_button(3)):
self._rear = True
if (self.joystick.get_button(2)):
self._rear = False
control = VehicleControl()
control.steer = steering_axis
control.throttle = (acc_axis + 1) / 2.0
control.brake = (brake_axis + 1) / 2.0
if control.brake < 0.001:
control.brake = 0.0
control.hand_brake = 0
control.reverse = self._rear
control.steer -= 0.0822
#print("steer %f, throttle %f, brake %f" % (control.steer, control.throttle, control.brake))
pygame.event.pump()
return control
def _compute_action(self, rgb_image, speed, directions=None):
#shit for demo
img = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2BGR)
cv2.imwrite(self.img_dir + "/image_" + str(self.nr_img) + ".jpg", img)
#shit for demo
rgb_image = rgb_image[self._image_cut[0]:self._image_cut[1], :]
steer, acc, brake = self._control_function(rgb_image, speed,
directions)
# This a bit biased, but is to avoid fake breaking
if brake < 0.1:
brake = 0.0
if acc > brake:
brake = 0.0
# We limit speed to 35 km/h to avoid
if speed > 10.0 and brake == 0:
acc = 0.0
control = VehicleControl()
control.steer = steer
control.throttle = acc
control.brake = brake
control.hand_brake = 0
control.reverse = 0
return control
def control(self):
vcontrol = VehicleControl()
# Press Y
if self.controller.get_button(3):
return None
# Left stick
steer = self.controller.get_axis(0)
if abs(steer) >= 0.1:
vcontrol.steer = steer / 2.
# Right stick
throttle = -self.controller.get_axis(4)
if throttle > 0:
vcontrol.throttle = abs(throttle) / 1.5
else:
vcontrol.brake = abs(throttle)
# Press right stick
if self.controller.get_button(10):
vcontrol.hand_brake = True
self.client.send_control(vcontrol)
self.info[
'Throttle'] = vcontrol.throttle if throttle > 0 else -vcontrol.brake
self.info['Steer'] = vcontrol.steer
def send_control_command(client, throttle, steer, brake,
hand_brake=False, reverse=False):
"""Send control command to CARLA client.
Send control command to CARLA client.
Args:
client: The CARLA client object
throttle: Throttle command for the sim car [0, 1]
steer: Steer command for the sim car [-1, 1]
brake: Brake command for the sim car [0, 1]
hand_brake: Whether the hand brake is engaged
reverse: Whether the sim car is in the reverse gear
"""
control = VehicleControl()
# Clamp all values within their limits
steer = np.fmax(np.fmin(steer, 1.0), -1.0)
throttle = np.fmax(np.fmin(throttle, 1.0), 0)
brake = np.fmax(np.fmin(brake, 1.0), 0)
control.steer = steer
control.throttle = throttle
control.brake = brake
control.hand_brake = hand_brake
control.reverse = reverse
client.send_control(control)
def get_control(self, wp_angle, wp_angle_speed, speed_factor, current_speed):
control = VehicleControl()
current_speed = max(current_speed, 0)
steer = self.params['steer_gain'] * wp_angle
if steer > 0:
control.steer = min(steer, 1)
else:
control.steer = max(steer, -1)
if math.fabs(wp_angle_speed) < 0.1:
target_speed_adjusted = self.params['target_speed'] * speed_factor
# Depending on the angle of the curve the speed is either 20 (beginning) 15 (most of it)
elif math.fabs(wp_angle_speed) < 0.5:
target_speed_adjusted = 20 * speed_factor
else:
target_speed_adjusted = 15 * speed_factor
self.pid.target = target_speed_adjusted
pid_gain = self.pid(feedback=current_speed)
throttle = min(max(self.params['default_throttle'] - 1.3 * pid_gain, 0),
self.params['throttle_max'])
if pid_gain > 0.5:
brake = min(0.35 * pid_gain * self.params['brake_strength'], 1)
else:
brake = 0
control.throttle = max(throttle, 0)
control.brake = brake
return control
def _get_keyboard_control(self, keys, measurements):
"""
Return a VehicleControl message based on the pressed keys. Return None
if a new episode was requested.
"""
if keys[K_p]:
control = measurements.player_measurements.autopilot_control
control.steer += random.uniform(-0.1, 0.1)
return control
if keys[K_r]:
return None
control = VehicleControl()
if keys[K_LEFT] or keys[K_a]:
control.steer = -1.0
if keys[K_RIGHT] or keys[K_d]:
control.steer = 1.0
if keys[K_UP] or keys[K_w]:
control.throttle = 1.0
if keys[K_DOWN] or keys[K_s]:
control.brake = 1.0
if keys[K_SPACE]:
control.hand_brake = True
if keys[K_q]:
self._is_on_reverse = not self._is_on_reverse
control.reverse = self._is_on_reverse
return control
def _get_keyboard_control(self, keys):
"""
Return a VehicleControl message based on the pressed keys. Return None
if a new episode was requested.
"""
if keys[K_r]:
return None
control = VehicleControl()
if keys[K_LEFT] or keys[K_a]:
control.steer = -0.5
if keys[K_RIGHT] or keys[K_d]:
control.steer = 0.5
if keys[K_UP] or keys[K_w]:
control.throttle = 0.7
if keys[K_DOWN] or keys[K_s]:
control.brake = 1.0
if keys[K_SPACE]:
control.hand_brake = True
if keys[K_q]:
self._is_on_reverse = not self._is_on_reverse
if keys[K_p]:
self._enable_autopilot = not self._enable_autopilot
if keys[K_2]:
self._command = 2
if keys[K_3]:
self._command = 3
if keys[K_4]:
self._command = 4
if keys[K_5]:
self._command = 5
control.reverse = self._is_on_reverse
return control
def _get_keyboard_control(self, keys):
"""
Return a VehicleControl message based on the pressed keys. Return None
if a new episode was requested.
"""
if keys[K_r]:
return None
control = VehicleControl()
if keys[K_LEFT] or keys[K_a]:
control.steer = -0.5
if keys[K_RIGHT] or keys[K_d]:
control.steer = 0.5
if keys[K_UP] or keys[K_w]:
control.throttle = 0.7
if keys[K_DOWN] or keys[K_s]:
control.brake = 1.0
if keys[K_SPACE]:
control.hand_brake = True
if keys[K_q]:
self._is_on_reverse = not self._is_on_reverse
if keys[K_p]:
self._enable_autopilot = not self._enable_autopilot
if keys[K_2]:
self._command = 2
if keys[K_3]:
self._command = 3
if keys[K_4]:
self._command = 4
if keys[K_5]:
self._command = 5
control.reverse = self._is_on_reverse
return control
def _control_using_agent(self, action):
'''
Here we pass the action output by our agent
and control the car
outputs :
As of now consider the agent also outputs the keys W, A, S, D, space, reverse
so according to the output vector "action"
For example :
action = [1, 1, 0, 0, 0, 0] => it uses throttle and steer left
action = [0, 0, 0, 0, 0, 1] => car will be on reverse gear
'''
'''To be completed'''
# if action[6]:
# # if r is pressed
# return None
control = VehicleControl()
if action[1]:
control.steer = -1.0
if action[3]:
control.steer = 1.0
if action[0]:
control.throttle = 1.0
if action[2]:
control.brake = 1.0
if action[4]:
control.hand_brake = True
if action[5]:
self._is_on_reverse = not self._is_on_reverse
control.reverse = self._is_on_reverse
return control
def _get_keyboard_control(self, keys):
"""
Return a VehicleControl message based on the pressed keys. Return None
if a new episode was requested.
"""
if keys[K_r]:
return None
control = VehicleControl()
if keys[K_LEFT] or keys[K_a]:
self._control.steer += -0.02
self._control.steer = max(self._control.steer, -1.0)
control.steer = -1.0
if keys[K_RIGHT] or keys[K_d]:
self._control.steer += 0.02
self._control.steer = min(self._control.steer, 1.0)
control.steer = 1.0
if keys[K_l] or keys[K_SPACE]:
self._control.steer = 0
if keys[K_UP] or keys[K_w]:
control.throttle = 1.0
self._control.throttle = 0.6
self._control.throttle = min(self._control.throttle, 1)
self._control.brake = 0.0
if keys[K_DOWN] or keys[K_s]:
control.brake = 1.0
self._control.brake = 1.0
self._control.throttle = 0.0
if keys[K_q]:
self._is_on_reverse = not self._is_on_reverse
if keys[K_p]:
self._enable_autopilot = not self._enable_autopilot
control.reverse = self._is_on_reverse
self._control.reverse = self._is_on_reverse
return control
def _get_keyboard_control(self, keys):
"""
Return a VehicleControl message based on the pressed keys. Return None
if a new episode was requested.
"""
if keys[K_r]:
return None, None
if keys[K_t]:
self.should_display = not self.should_display
return 'done', None
if keys[K_m]:
self.manual = True
return 'done', None
if keys[K_n]:
self.manual = False
return 'done', None
if keys[K_v]:
self.endnow = True
return 'done', None
control = VehicleControl()
if keys[K_LEFT] or keys[K_a]:
control.steer = -1.0
if keys[K_RIGHT] or keys[K_d]:
control.steer = 1.0
if keys[K_UP] or keys[K_w]:
control.throttle = 1.0
if keys[K_DOWN] or keys[K_s]:
control.brake = 1.0
if keys[K_SPACE]:
control.hand_brake = True
if keys[K_q]:
self._is_on_reverse = not self._is_on_reverse
if keys[K_c]:
self.manual_control = not self.manual_control
if keys[K_p]:
self._enable_autopilot = not self._enable_autopilot
control.reverse = self._is_on_reverse
reward = None
if keys[K_1]:
reward = -1
if keys[K_2]:
reward = -0.5
if keys[K_3]:
reward = -0.25
if keys[K_4]:
reward = -0.1
if keys[K_5]:
reward = 0
if keys[K_6]:
reward = 0.1
if keys[K_7]:
reward = 0.25
if keys[K_8]:
reward = 0.5
if keys[K_9]:
reward = 1
return control, reward
def get_control_from_a(a):
control = VehicleControl()
control.steer = a[0]
control.throttle = a[1]
control.brake = a[2]
control.hand_brake = bool(a[3])
control.reverse = bool(a[4])
return control
def _get_keyboard_control(self, keys, measurements, sensor_data):
"""
Return a VehicleControl message based on the pressed keys. Return None
if a new episode was requested.
"""
self._at_intersection = False
if keys[K_r]:
return None
if self._NNagent_drives:
if keys[K_LEFT] or keys[K_a]:
control = self.NNagent.run_step(measurements, sensor_data, 3,
None)
elif keys[K_RIGHT] or keys[K_d]:
control = self.NNagent.run_step(measurements, sensor_data, 4,
None)
elif keys[K_UP] or keys[K_w]:
control = self.NNagent.run_step(measurements, sensor_data, 2,
None)
else:
control = self.NNagent.run_step(measurements, sensor_data, -1,
None)
if keys[K_q]:
self._is_on_reverse = not self._is_on_reverse
if keys[K_p]:
self._enable_autopilot = True
self._NNagent_drives = not self._NNagent_drives
if keys[K_n]:
print("Turning off")
self._NNagent_drives = not self._NNagent_drives
if keys[K_i]:
self._at_intersection = True
control.reverse = self._is_on_reverse
else:
control = VehicleControl()
if keys[K_LEFT] or keys[K_a]:
control.steer = -1.0
if keys[K_RIGHT] or keys[K_d]:
control.steer = 1.0
if keys[K_UP] or keys[K_w]:
control.throttle = 1.0
if keys[K_DOWN] or keys[K_s]:
control.brake = 1.0
if keys[K_SPACE]:
control.hand_brake = True
if keys[K_q]:
self._is_on_reverse = not self._is_on_reverse
if keys[K_p]:
self._enable_autopilot = not self._enable_autopilot
if keys[K_n]:
print("Turning on")
self._NNagent_drives = not self._NNagent_drives
self._enable_autopilot = False
if keys[K_i]:
self._at_intersection = True
control.reverse = self._is_on_reverse
return control
def _get_XBOX_control(self, joystick):
control = VehicleControl()
control.throttle = 0.4 * (joystick.get_axis(5) + 1)
if control.throttle > 0.6:
control.throttle = 0.6
# if control.throttle <0.3:
# control.throttle = 0
# elif control.throttle<0.7:
# control.throttle = 0.5
# else:
# control.throttle =1.0
control.brake = 0.5 * (joystick.get_axis(2) + 1)
control.brake = max(0, control.brake - 0.1)
control.steer = joystick.get_axis(0)
if(abs(control.steer)<0.05):
control.steer = 0
if control.steer <=-0.05:
control.steer += 0.05
if control.steer >=0.05:
control.steer -= 0.05
control.steer = 0.8 * control.steer
control.reverse = self._is_on_reverse
# command = joystick.get_hat(0)
# if command[0] == -1:
# self._command = 3
# elif command[0] == 1:
# self._command = 4
# if command[1] == -1:
# self._command = 5
# elif command[1] == 1:
# self._command = 2
# return control
if joystick.get_axis(3) > 0.5:
self._command = 4
elif joystick.get_axis(3) < -0.5:
self._command = 3
elif joystick.get_axis(4) > 0.5:
self._command = 5
elif joystick.get_axis(4) < -0.5:
self._command = 2
return control
def _get_autopilot_control(self, measurements):
control = VehicleControl()
control.steer = measurements.player_measurements.autopilot_control.steer
control.throttle = measurements.player_measurements.autopilot_control.throttle
control.brake = measurements.player_measurements.autopilot_control.brake
control.hand_brake = measurements.player_measurements.autopilot_control.hand_brake
control.reverse = measurements.player_measurements.autopilot_control.reverse
return control
def _get_steering_control(self):
numAxes = self.js.get_numaxes()
jsInputs = [float(self.js.get_axis(i)) for i in range(numAxes)]
# print('Js inputs [%s]' % ', '.join(map(str, jsInputs)))
control = VehicleControl()
control.steer = jsInputs[0]
if ((1 - jsInputs[1]) / 2) > 0.001:
control.brake = (1 - jsInputs[1]) / 2
else:
control.brake = 0
if ((1 - jsInputs[2]) / 2) > 0.001:
control.throttle = (1 - jsInputs[2]) / 2
else:
control.throttle = 0
control.hand_brake = 0.0
control.reverse = 0.0
# print(control)
return control
def _get_XBOX_control(self, joystick):
control = VehicleControl()
control.throttle = 0.4 * (joystick.get_axis(5) + 1)
if control.throttle > 0.6:
control.throttle = 0.6
# if control.throttle <0.3:
# control.throttle = 0
# elif control.throttle<0.7:
# control.throttle = 0.5
# else:
# control.throttle =1.0
control.brake = 0.5 * (joystick.get_axis(2) + 1)
control.brake = max(0, control.brake - 0.1)
control.steer = joystick.get_axis(0)
if (abs(control.steer) < 0.05):
control.steer = 0
if control.steer <= -0.05:
control.steer += 0.05
if control.steer >= 0.05:
control.steer -= 0.05
control.steer = 0.8 * control.steer
control.reverse = self._is_on_reverse
# command = joystick.get_hat(0)
# if command[0] == -1:
# self._command = 3
# elif command[0] == 1:
# self._command = 4
# if command[1] == -1:
# self._command = 5
# elif command[1] == 1:
# self._command = 2
# return control
if joystick.get_axis(3) > 0.5:
self._command = 4
elif joystick.get_axis(3) < -0.5:
self._command = 3
elif joystick.get_axis(4) > 0.5:
self._command = 5
elif joystick.get_axis(4) < -0.5:
self._command = 2
return control
def _on_loop(self, frame):
self._timer.tick()
skip_frames = 40
measurements, sensor_data = self.client.read_data()
current_position = vec3tovec2(measurements.player_measurements.transform.location)
self._velocities.append(measurements.player_measurements.forward_speed * 3.6) # convert to km/h
steer = 0.0
acceleration = 0.0
for name, measurement in sensor_data.items():
model_input = preprocess(measurement.data)
model_input = np.array(model_input / 127.5 - 1, dtype=np.float32)
model_input = np.expand_dims(model_input, axis=0)
ret = self._model.predict(model_input)[0]
steer = ret[0]
acceleration = ret[1]
if USE_SPEED_CONSTRAINTS:
if measurements.player_measurements.forward_speed * 3.6 < MINIMAL_SPEED:
acceleration = 0.7
elif measurements.player_measurements.forward_speed * 3.6 > MAXIMAL_SPEED:
acceleration = 0
control = VehicleControl()
control.steer = steer
control.throttle = acceleration
self.client.send_control(control)
if frame < skip_frames:
logging.info("Skipping first {} frames...".format(skip_frames))
return True
self.line_points.append(current_position)
self.points_x.append(current_position[0])
self.points_y.append(current_position[1])
if len(self.line_points) > 1:
dist_from_start = distance(self.line_points[0], current_position)
else:
dist_from_start = 10000
if dist_from_start < 1 and frame > skip_frames + 100:
logging.info("Position: {} is already logged".format(current_position))
return False
if self._timer.elapsed_seconds_since_lap() > 0.5:
self._print_player_measurements(control)
logging.info("Add point: [{:.4f},{:.4f}], points count: {:0>4d}, distance from start: {:.4f}".format(
current_position[0],
current_position[1],
len(self.line_points),
dist_from_start))
self._timer.lap()
return True
def decode_control(self, cod):
#将数字的ｃｏｎｔｒｏｌ转换为VehicleControl()
control = VehicleControl()
control.steer = 0
control.throttle = 0
control.brake = 0
control.hand_brake = False
control.reverse = False
th, steer = cod
if th > 0:
control.throttle = min(th, 1.0)
if th < 0:
control.brake = min(-th, 1.0)
control.steer = max(min(steer, 1.0), -1.0)
# if cod > 9:
# control.hand_brake = True
# if cod == 10:
# control.steer = -1
# elif cod == 11:
# control.steer = 1
# return control
# if cod == 9:
# control.reverse = True
# control.throttle = 1
# return control
# if cod % 3 == 1:
# control.brake = 1
# elif cod % 3 == 2:
# control.throttle = 1
# if cod // 3 == 1:
# control.steer = 1
# elif cod // 3 == 2:
# control.steer = -1
return control
def getKeyboardControl():
control = VehicleControl()
if win32api.GetAsyncKeyState(ord('A')):
control.steer = -1.0
if win32api.GetAsyncKeyState(ord('D')):
control.steer = 1.0
if win32api.GetAsyncKeyState(ord('W')):
control.throttle = 1.0
if win32api.GetAsyncKeyState(ord('S')):
control.brake = 1.0
return control
def _get_joystick_control(self):
# define ids of important axes on joystick
TRIGGERS = 2
X_AXIS = 0
control = VehicleControl()
control.throttle = 0
control.brake = 0
# dont know why but axes in PYGAME are inverted, LEFT_TRIGGGER is >0 and RIGHT_TRIGGER <0
# LEFT_TRIGGER is for braking
trigger_value = self._current_joystick.get_axis(TRIGGERS)
if trigger_value > 0:
control.brake = trigger_value
# RIGHT_TRIGGER is for throttle
elif trigger_value < 0:
control.throttle = -trigger_value
control.steer = self._current_joystick.get_axis(X_AXIS)
if X_AXIS_DEADZONE[0] < control.steer < X_AXIS_DEADZONE[1]:
control.steer = 0
return control
def action_to_control(self, action, last_measurements=None):
control = VehicleControl()
if self.action_type == 'carla-original':
if type(action) == np.ndarray:
action = action.item()
if type(action) != int:
print('Unexpected action got {}'.format(type(action)))
assert type(action) == int, 'Action should be an int'
action = self.discrete_actions[action]
if last_measurements is not None and last_measurements.player_measurements.forward_speed * 3.6 < 30:
control.throttle = action[0]
elif action[0] > 0.:
control.throttle = 0.
control.steer = action[1]
elif self.action_type == 'continuous':
control.throttle = min(1, max(0.0, action[0]))
control.brake = min(1, max(0.0, action[1]))
control.steer = min(1, max(-1, action[2]))
# print('Control: {}, {}, {}'.format(control.throttle, control.brake, control.steer))
return control
def _get_gamepad_control(self):
control = VehicleControl()
gamepad = GamepadManager()
control.steer = gamepad.axis_states[GamepadManager.AxisMap.LEFT_X]
control.throttle = (gamepad.axis_states[GamepadManager.AxisMap.RT] +
1) / 2.0
control.brake = (gamepad.axis_states[GamepadManager.AxisMap.LT] +
1) / 2.0
if gamepad.button_states[GamepadManager.ButtonMap.X]:
self._is_on_reverse = not self._is_on_reverse
if gamepad.button_states[GamepadManager.ButtonMap.B]:
self._enable_autopilot = not self._enable_autopilot
control.reverse = self._is_on_reverse
return control
def _get_keyboard_control(self, keys):
control = VehicleControl()
if keys[pl.K_LEFT] or keys[pl.K_a]:
control.steer = -1.0
if keys[pl.K_RIGHT] or keys[pl.K_d]:
control.steer = 1.0
if keys[pl.K_UP] or keys[pl.K_w]:
control.throttle = 1.0
if keys[pl.K_DOWN] or keys[pl.K_s]:
control.brake = 1.0
if keys[pl.K_SPACE]:
control.hand_brake = True
control.reverse = self._vehicle_in_reverse
return control
def run_step(self, measurements, sensor_data, directions, target):
control = VehicleControl()
control.throttle = 0.9
return control
