def __init__(self,
city_name='Town01',
name_to_save='Test',
continue_experiment=False,
save_images=False,
distance_for_success=2.0):
"""
Args
city_name:
name_to_save:
continue_experiment:
save_images:
distance_for_success:
collisions_as_failure: if this flag is set to true, episodes will terminate as failure, when the car collides.
"""
self.__metaclass__ = abc.ABCMeta
self._city_name = city_name
self._base_name = name_to_save
# The minimum distance for arriving into the goal point in
# order to consider ir a success
self._distance_for_success = distance_for_success
# The object used to record the benchmark and to able to continue after
self._recording = Recording(name_to_save=name_to_save,
continue_experiment=continue_experiment,
save_images=save_images)
# We have a default planner instantiated that produces high level commands
self._planner = Planner(city_name)
# TO keep track of the previous collisions
self._previous_pedestrian_collision = 0
self._previous_vehicle_collision = 0
self._previous_other_collision = 0
def __init__(
self,
city_name='Town01',
name_to_save='Test',
continue_experiment=False,
save_images=False,
distance_for_success=2.0
):
self.__metaclass__ = abc.ABCMeta
self._city_name = city_name
self._base_name = name_to_save
# The minimum distance for arriving into the goal point in
# order to consider ir a success
self._distance_for_success = distance_for_success
# The object used to record the benchmark and to able to continue after
self._recording = Recording(name_to_save=name_to_save,
continue_experiment=continue_experiment,
save_images=save_images
)
# We have a default planner instantiated that produces high level commands
self._planner = Planner(city_name)
self._episode_number = 0
def reset(self, vehicle_num):
#if not self.is_process_alive(self.server_pid):
#self.setup_client_and_server()
self.nospeed_times = 0
pose_type = random.choice(self.poses)
#pose_type = self.poses[0]
self.current_position = random.choice(
pose_type) #start and end index
#self.current_position = (53,67)
# self.number_of_vehicles = random.randint( self.vehicle_pair[0],self.vehicle_pair[1])
# self.number_of_pedestrians = random.randint( self.vehicle_pair[0],self.vehicle_pair[1])
self.number_of_vehicles = vehicle_num
self.number_of_pedestrians = 0
self.weather = random.choice(self.weather_set)
self.timestep = 0
self.collision = 0
self.collision_vehicles = 0
self.collision_other = 0
self.stuck_cnt = 0
self.collision_cnt = 0
self.offroad_cnt = 0
self.ignite = False
settings = carla_config.make_carla_settings()
settings.set(NumberOfVehicles=self.number_of_vehicles,
NumberOfPedestrians=self.number_of_pedestrians,
WeatherId=self.weather)
self.carla_setting = settings
self.scene = self.game.load_settings(settings)
self.game.start_episode(
self.current_position[0]) #set the start position
#print(self.current_position)
self.target_transform = self.scene.player_start_spots[
self.current_position[1]]
self.planner = Planner(self.scene.map_name)
#skip the car fall to sence frame
for i in range(self.speed_up_steps):
self.control = VehicleControl()
self.control.steer = 0
self.control.throttle = 0.025 * i
self.control.brake = 0
self.control.hand_brake = False
self.control.reverse = False
time.sleep(0.05)
send_success = self.send_control(self.control)
if not send_success:
return None
self.game.send_control(self.control)
#measurements, sensor_data = self.game.read_data() #measurements,sensor
#direction =self.get_directions(measurements,self.target_transform,self.planner)
#self.get_state(measurements,sensor_data,direction)
measurements, sensor_data = self.game.read_data() #measurements,sensor
directions = self.get_directions(measurements, self.target_transform,
self.planner)
if directions is None or measurements is None:
return None
state, _, _ = self.get_state(measurements, sensor_data, directions)
return state
def __init__(self,
obs_converter,
action_converter,
env_id,
random_seed=0,
exp_suite_name='TrainingSuite',
reward_class_name='RewardCarla',
host='127.0.0.1',
port=2000,
city_name='Town01',
subset=None,
video_every=100,
video_dir='./video/',
distance_for_success=2.0,
benchmark=False):
self.logger = get_carla_logger()
self.logger.info('Environment {} running in port {}'.format(
env_id, port))
self.host, self.port = host, port
self.id = env_id
self._obs_converter = obs_converter
self.observation_space = obs_converter.get_observation_space()
self._action_converter = action_converter
self.action_space = self._action_converter.get_action_space()
if benchmark:
self._experiment_suite = getattr(experiment_suites_benchmark,
exp_suite_name)(city_name)
else:
self._experiment_suite = getattr(experiment_suites,
exp_suite_name)(city_name, subset)
self._reward = getattr(rewards, reward_class_name)()
self._experiments = self._experiment_suite.get_experiments()
self.subset = subset
self._make_carla_client(host, port)
self._distance_for_success = distance_for_success
self._planner = Planner(city_name)
self.done = False
self.last_obs = None
self.last_distance_to_goal = None
self.last_direction = None
self.last_measurements = None
np.random.seed(random_seed)
self.video_every = video_every
self.video_dir = video_dir
self.video_writer = None
self._success = False
self._failure_timeout = False
self._failure_collision = False
self.benchmark = benchmark
self.benchmark_index = [0, 0, 0]
try:
if not os.path.isdir(self.video_dir):
os.makedirs(self.video_dir)
except OSError:
pass
self.steps = 0
self.num_episodes = 0
def __init__(self, config=ENV_CONFIG):
"""
Carla Gym Environment class implementation. Creates an OpenAI Gym compatible driving environment based on
Carla driving simulator.
:param config: A dictionary with environment configuration keys and values
"""
self.config = config
self.city = self.config["server_map"].split("/")[-1]
if self.config["enable_planner"]:
self.planner = Planner(self.city)
if config["discrete_actions"]:
self.action_space = Discrete(len(DISCRETE_ACTIONS))
else:
self.action_space = Box(-1.0, 1.0, shape=(2, ), dtype=np.uint8)
if config["use_depth_camera"]:
image_space = Box(-1.0,
1.0,
shape=(config["y_res"], config["x_res"],
1 * config["framestack"]),
dtype=np.float32)
else:
image_space = Box(0.0,
255.0,
shape=(config["y_res"], config["x_res"],
3 * config["framestack"]),
dtype=np.float32)
if self.config["use_image_only_observations"]:
self.observation_space = image_space
else:
self.observation_space = Tuple([
image_space,
Discrete(len(COMMANDS_ENUM)), # next_command
Box(-128.0, 128.0, shape=(2, ), dtype=np.float32)
]) # forward_speed, dist to goal
self._spec = lambda: None
self._spec.id = "Carla-v0"
self._seed = ENV_CONFIG["seed"]
self.server_port = None
self.server_process = None
self.client = None
self.num_steps = 0
self.total_reward = 0
self.prev_measurement = None
self.prev_image = None
self.episode_id = None
self.measurements_file = None
self.weather = None
self.scenario = None
self.start_pos = None
self.end_pos = None
self.start_coord = None
self.end_coord = None
self.last_obs = None
def __init__(self, config=ENV_CONFIG):
self.config = config
self.city = self.config["server_map"].split("/")[-1]
if self.config["enable_planner"]:
self.planner = Planner(self.city)
# The Action Space
if config["discrete_actions"]:
self.action_space = Discrete(
len(DISCRETE_ACTIONS
)) # It will be transformed to continuous 2D action.
else:
self.action_space = Box(-1.0, 1.0, shape=(2, ),
dtype=np.float32) # 2D action.
if config["use_depth_camera"]:
image_space = Box(-1.0,
1.0,
shape=(config["y_res"], config["x_res"],
1 * config["framestack"]),
dtype=np.float32)
else:
image_space = Box(0,
255,
shape=(config["y_res"], config["x_res"],
3 * config["framestack"]),
dtype=np.uint8)
# The Observation Space
self.observation_space = Tuple([
image_space,
Discrete(len(COMMANDS_ENUM)), # next_command
Box(-128.0, 128.0, shape=(2, ),
dtype=np.float32) # forward_speed, dist to goal
])
# TODO(ekl) this isn't really a proper gym spec
self._spec = lambda: None
self._spec.id = "Carla-v0"
self.server_port = None
self.server_process = None
self.client = None
self.num_steps = 0
self.total_reward = 0
self.prev_measurement = None
self.prev_image = None
self.episode_id = None
self.measurements_file = None
self.weather = None
self.scenario = None
self.start_pos = None
self.end_pos = None
self.start_coord = None
self.end_coord = None
self.last_obs = None
def __init__(self,
client,
frame_skip=1,
cam_width=800,
cam_height=600,
town_string='Town01'):
super(StraightDriveEnv, self).__init__()
self.frame_skip = frame_skip
self.client = client
self._planner = Planner(town_string)
camera0 = Camera('CameraRGB')
camera0.set(CameraFOV=100)
camera0.set_image_size(cam_height, cam_width)
camera0.set_position(200, 0, 140)
camera0.set_rotation(-15.0, 0, 0)
self.start_goal_pairs = [[36, 40], [39, 35], [110, 114], [7,
3], [0, 4],
[68, 50], [61, 59], [47, 64], [147, 90],
[33, 87], [26, 19], [80, 76], [45, 49],
[55, 44], [29, 107], [95, 104], [84, 34],
[53, 67], [22, 17], [91, 148], [20, 107],
[78, 70], [95, 102], [68, 44], [45, 69]]
vehicles = 0
pedestrians = 0
weather = 1
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather,
)
settings.randomize_seeds()
settings.add_sensor(camera0)
self.scene = self.client.load_settings(settings)
img_shape = (cam_width, cam_height, 3)
self.observation_space = spaces.Tuple(
(spaces.Box(-np.inf, np.inf, (3, )), spaces.Box(0, 255,
img_shape)))
self.action_space = spaces.Box(-np.inf, np.inf, shape=(3, ))
self.prev_state = np.array([0., 0., 0.])
self.prev_collisions = np.array([0., 0., 0.])
self.prev_intersections = np.array([0., 0.])
def get_command(index, planner_in, last_end):
if index == pos.shape[0]-1:
# this is the last one, return follow
return 2, None, -1
if index > 0:
# when we have a new trajectory
if sldist(pos[index - 1], pos[index]) > 0.2 * 9.7 * 1.5:
planner_in = Planner(CityName)
print("starting a new trajectory")
last_inter = is_away_from_inter[index]
count_inter_changes = 0
#end_index = last_end - 1
end_index = index
while True:
end_index += 1
if sldist(pos[end_index - 1], pos[end_index]) > 0.2 * 9.7 * 1.5 or \
end_index == pos.shape[0] - 1:
if sldist(pos[end_index - 1], pos[end_index]) > 0.2 * 9.7 * 1.5:
end_index -= 1
direction = planner.get_next_command(pos[index],
ori[index],
pos[end_index],
ori[end_index])
if math.fabs(direction)<0.1:
direction = 2.0
return direction, planner_in, end_index
if last_inter != is_away_from_inter[end_index]:
last_inter = not last_inter
count_inter_changes += 1
if count_inter_changes < 3:
continue
direction = planner.get_next_command(pos[index],
ori[index],
pos[end_index],
ori[end_index])
if math.fabs(direction) > 0.1:
return direction, planner_in, end_index
def __init__(self, config=ENV_CONFIG):
self.config = config
self.city = self.config["server_map"].split("/")[-1]
if self.config["enable_planner"]:
self.planner = Planner(self.city)
self.action_space = Discrete(len(DISCRETE_ACTIONS))
# RGB Camera
self.frame_shape = (config["y_res"], config["x_res"])
image_space = Box(
0, 1, shape=(
config["y_res"], config["x_res"],
FRAME_DEPTH * config["framestack"]), dtype=np.float32)
self.observation_space = image_space
# TODO(ekl) this isn't really a proper gym spec
self._spec = lambda: None
self._spec.id = "Carla-v0"
self.server_port = None
self.server_process = None
self.client = None
self.num_steps = 0
self.total_reward = 0
self.prev_measurement = None
self.prev_image = None
self.episode_id = None
self.measurements_file = None
self.weather = None
self.scenario = None
self.start_pos = None
self.end_pos = None
self.start_coord = None
self.end_coord = None
self.last_obs = None
self.last_full_obs = None
self.framestack = [None] * config["framestack"]
self.framestack_index = 0
self.running_restarts = 0
self.on_step = None
self.on_next = None
self.photo_index = 1
self.episode_index = 0
def __init__(self, waypointerconf, planner_or_map_name):
self._planner = Planner(planner_or_map_name) if isinstance(
planner_or_map_name, str) else planner_or_map_name
self._params = waypointerconf
# internal carla objects for planning
self._city_track = self._planner._city_track
# pdb.set_trace()
# print(self.LANE_WIDTH_PIXELS * self._city_track.get_pixel_density())
self._map = self._city_track._map
self._converter = self._map._converter
self._graph = self._map._graph
self._grid = self._map._grid
self._grid_structure = self._grid._structure # shape [49, 41], of zeros and ones (0==road, 1==not_road)
# goal and waypoint variables
self._road_nodes = self.get_road_nodes()
self.reset_route()
# adjustment information for extra curvy map corners
res = self._graph._resolution
self._corner_nodes = [(0, 0), (res[0] - 1, 0), (0, res[1] - 1),
(res[0] - 1, res[1] - 1)]
corner_nodes_adjacent = [(1, 1), (res[0] - 2, 1), (1, res[1] - 2),
(res[0] - 2, res[1] - 2)]
self._corner_shift_ori = np.array(corner_nodes_adjacent) - np.array(
self._corner_nodes)
# traffic light cached data
self.traffic_light_inodes_and_oris = None
self.last_traffic_light_state = None
self.intersection_count = 0
self.red_light_violations = 0
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='Town01',
help='plot the map of the current city (needs to match active map in '
'server, options: Town01 or Town02)')
argparser.add_argument(
'-c',
'--city-name',
metavar='C',
default='Town01',
help='The town that is going to be used on benchmark '
'(needs to match active town in server, options: Town01 or Town02)')
argparser.add_argument('-n',
'--enable-noise',
action='store_true',
help='Add noise to player commands')
argparser.add_argument(
'-mo',
'--collection-mode',
default='keyboard',
help=
'For data collection: keyboard = use keyboard, steering = use steering wheel, auto = use autopilot'
)
argparser.add_argument('-s',
'--save-data',
action='store_true',
help='Store the demonstrated data to disk')
argparser.add_argument('-l',
'--player-name',
metavar='L',
default='AshishMehta',
help='Name of the demonstrator')
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__)
if args.save_data:
file_count = 0
if not os.path.exists('./Data_Set/' + args.player_name):
os.makedirs('./Data_Set/' + args.player_name)
for _ in glob.glob('./Data_Set/' + args.player_name + '/*'):
file_count += 1
file_count = int(file_count / 2)
f = h5py.File(
"./Data_Set/" + args.player_name +
"/Training_Data{}.h5".format(file_count), "w")
if not os.path.exists('./Data_Set/' + args.player_name +
'/Training_Data{}/'.format(file_count)):
os.makedirs('./Data_Set/' + args.player_name +
'/Training_Data{}/'.format(file_count))
json_folder = './Data_Set/' + args.player_name + '/Training_Data{}/'.format(
file_count)
dset_target = f.create_dataset('targets', (1, 34),
maxshape=(None, 50),
dtype=np.float128)
dset_im_front = f.create_dataset('Camera/RGB_front',
(1, WINDOW_HEIGHT, WINDOW_WIDTH, 3),
maxshape=(None, WINDOW_HEIGHT,
WINDOW_WIDTH, 3),
dtype=np.uint8)
dset_im_left = f.create_dataset(
'Camera/RGB_left', (1, MINI_WINDOW_HEIGHT, MINI_WINDOW_WIDTH, 3),
maxshape=(None, MINI_WINDOW_HEIGHT, MINI_WINDOW_WIDTH, 3),
dtype=np.uint8)
dset_im_right = f.create_dataset(
'Camera/RGB_right', (1, MINI_WINDOW_HEIGHT, MINI_WINDOW_WIDTH, 3),
maxshape=(None, MINI_WINDOW_HEIGHT, MINI_WINDOW_WIDTH, 3),
dtype=np.uint8)
dset_im = [dset_im_front, dset_im_left, dset_im_right]
else:
dset_target = None
dset_im = None
json_folder = None
while True:
try:
with make_carla_client(args.host, args.port) as client:
planner_obj = Planner(args.city_name)
game = CarlaGame(client, planner_obj, args.map_name,
args.city_name, args.save_data,
args.enable_noise, args.collection_mode)
game.execute(dset_target, dset_im, json_folder)
break
except TCPConnectionError as error:
logging.error(error)
time.sleep(1)
def __init__(self, driver_conf):
Driver.__init__(self)
# some behaviors
self._autopilot = driver_conf.autopilot
self._reset_period = driver_conf.reset_period # those reset period are in the actual system time, not in simulation time
self._goal_reaching_threshold = 3
self.use_planner = driver_conf.use_planner
# we need the planner to find a valid episode, so we initialize one no matter what
self._world = None
self._vehicle = None
self._agent_autopilot = None
self._camera_center = None
self._spectator = None
# (last) images store for several cameras
self._data_buffers = dict()
self.update_once = False
self._collision_events = []
self.collision_sensor = None
if __CARLA_VERSION__ == '0.8.X':
self.planner = Planner(driver_conf.city_name)
else:
self.planner = None
self.use_planner = False
# resources
self._host = driver_conf.host
self._port = driver_conf.port
# various config files
self._driver_conf = driver_conf
self._config_path = driver_conf.carla_config
# some initializations
self._straight_button = False
self._left_button = False
self._right_button = False
self._rear = False
self._recording = False
self._skiped_frames = 20
self._stucked_counter = 0
self._prev_time = datetime.now()
self._episode_t0 = datetime.now()
self._vehicle_prev_location = namedtuple("vehicle", "x y z")
self._vehicle_prev_location.x = 0.0
self._vehicle_prev_location.y = 0.0
self._vehicle_prev_location.z = 0.0
self._camera_left = None
self._camera_right = None
self._camera_center = None
self._actor_list = []
self._sensor_list = []
self._weather_list = [
'ClearNoon', 'CloudyNoon', 'WetNoon', 'WetCloudyNoon',
'MidRainyNoon', 'HardRainNoon', 'SoftRainNoon', 'ClearSunset',
'CloudySunset', 'WetSunset', 'WetCloudySunset', 'MidRainSunset',
'HardRainSunset', 'SoftRainSunset'
]
self._current_weather = 4
self._current_command = 2.0
# steering wheel
self._steering_wheel_flag = True
if self._steering_wheel_flag:
self._is_on_reverse = False
self._control = VehicleControl()
self._parser = SafeConfigParser()
self._parser.read('wheel_config.ini')
self._steer_idx = int(
self._parser.get('G29 Racing Wheel', 'steering_wheel'))
self._throttle_idx = int(
self._parser.get('G29 Racing Wheel', 'throttle'))
self._brake_idx = int(self._parser.get('G29 Racing Wheel',
'brake'))
self._reverse_idx = int(
self._parser.get('G29 Racing Wheel', 'reverse'))
self._handbrake_idx = int(
self._parser.get('G29 Racing Wheel', 'handbrake'))
self.last_timestamp = lambda x: x
self.last_timestamp.elapsed_seconds = 0.0
self.last_timestamp.delta_seconds = 0.2
self.initialize_map(driver_conf.city_name)
def __init__(self, city_name):
self.__metaclass__ = abc.ABCMeta
self._planner = Planner(city_name)
def __init__(self, config=ENV_CONFIG, enable_autopilot=False):
self.enable_autopilot = enable_autopilot
self.config = config
self.config["x_res"], self.config["y_res"] = IMG_SIZE
self.city = self.config["server_map"].split("/")[-1]
if self.config["enable_planner"]:
self.planner = Planner(self.city)
self.intersections_node = self.planner._city_track._map.get_intersection_nodes(
)
self.intersections_pos = np.array([
self.planner._city_track._map.convert_to_world(
intersection_node)
for intersection_node in self.intersections_node
])
self.pre_intersection = np.array([0.0, 0.0])
# # Cartesian coordinates
self.headings = np.array([[1, 0], [-1, 0], [0, 1], [0, -1]])
# self.lrs_matrix = {"GO_STRAIGHT": np.array([[1,0],[0,1]]),\
# "TURN_RIGHT": np.array([[0,-1],[1,0]]),\
# "TURN_LEFT": np.array([[0,1],[-1,0]])}
# self.goal_heading = np.array([0.0,0.0])
# self.current_heading = None
# self.pre_heading = None
# self.angular_speed = None
# Angular degree
self.headings_degree = np.array(
[0.0, 180.0, 90.0, -90.0]) # one-one mapping to self.headings
self.lrs_degree = {
"GO_STRAIGHT": 0.0,
"TURN_LEFT": -90.0,
"TURN_RIGHT": 90.0
}
self.goal_heading_degree = 0.0
self.current_heading_degree = None
self.pre_heading_degree = None
self.angular_speed_degree = np.array(0.0)
# The Action Space
if config["discrete_actions"]:
self.action_space = Discrete(
len(DISCRETE_ACTIONS
)) # It will be transformed to continuous 2D action.
else:
self.action_space = Box(-1.0, 1.0, shape=(2, ),
dtype=np.float32) # 2D action.
if config["use_sensor"] == 'use_semantic':
image_space = Box(0.0,
255.0,
shape=(config["y_res"], config["x_res"],
1 * config["framestack"]),
dtype=np.float32)
elif config["use_sensor"] in ['use_depth', 'use_logdepth']:
image_space = Box(0.0,
255.0,
shape=(config["y_res"], config["x_res"],
1 * config["framestack"]),
dtype=np.float32)
elif config["use_sensor"] == 'use_rgb':
image_space = Box(0,
255,
shape=(config["y_res"], config["x_res"],
3 * config["framestack"]),
dtype=np.uint8)
elif config["use_sensor"] == 'use_2rgb':
image_space = Box(0,
255,
shape=(config["y_res"], config["x_res"],
2 * 3 * config["framestack"]),
dtype=np.uint8)
# The Observation Space
self.observation_space = Tuple([
image_space,
Discrete(len(COMMANDS_ENUM)), # next_command
Box(-128.0, 128.0, shape=(2, ),
dtype=np.float32) # forward_speed, dist to goal
])
# TODO(ekl) this isn't really a proper gym spec
self._spec = lambda: None
self._spec.id = "Carla-v0"
self.server_port = None
self.server_process = None
self.client = None
self.num_steps = 0
self.total_reward = 0
self.prev_measurement = None
self.prev_image = None
self.episode_id = None
self.measurements_file = None
self.weather = None
self.scenario = None
self.start_pos = None
self.end_pos = None
self.start_coord = None
self.end_coord = None
self.last_obs = None
self.cnt1 = None
self.displacement = None
self.next_command = "LANE_FOLLOW"
target_path = os.path.join(garbage_path, tail)
shutil.move(one_h5, target_path)
continue
pos.append(hin["targets"][:, 8: 10])
ori.append(hin["targets"][:, 21:24])
pos0 = np.concatenate(pos, axis=0)
pos = np.zeros((pos0.shape[0], 3))
pos[:, 0:2] = pos0
pos[:, 2] = 0.22
ori = np.concatenate(ori, axis=0)
# instantiate a planner
planner = Planner(CityName)
# compute is this position away from an intersection?
is_away_from_inter = []
for i in range(pos.shape[0]):
res = planner.test_position(pos[i, :])
is_away_from_inter.append(res)
is_away_from_inter = np.array(is_away_from_inter)
sldist = lambda c1, c2: math.sqrt((c2[0] - c1[0]) ** 2 + (c2[1] - c1[1]) ** 2)
def get_command(index, planner_in, last_end):
if index == pos.shape[0]-1:
# this is the last one, return follow
return 2, None, -1
def __init__(self, config=ENV_CONFIG, image_shape=64):
self.config = config
self.city = self.config["server_map"].split("/")[-1]
if self.config["enable_planner"]:
self.planner = Planner(self.city)
if config["discrete_actions"]:
self.action_space = Discrete(len(DISCRETE_ACTIONS))
else:
self.action_space = Box(-1.0, 1.0, shape=(2, ), dtype=np.float32)
if config["use_depth_camera"]:
image_space = Box(-1.0,
1.0,
shape=(config["y_res"], config["x_res"],
1 * config["framestack"]),
dtype=np.float32)
else:
image_space = Box(0,
255,
shape=(config["y_res"], config["x_res"],
3 * config["framestack"]),
dtype=np.uint8)
self.observation_space = Tuple( # forward_speed, dist to goal
[
image_space,
Discrete(len(COMMANDS_ENUM)), # next_command
Box(-128.0, 128.0, shape=(2, ), dtype=np.float32)
])
##TODO
image_space = Box(low=-1,
high=1,
shape=(
config["y_res"],
config["x_res"],
1 * config["framestack"],
),
dtype=np.float32)
self.observation_space = image_space
print('-' * 100)
print(self.observation_space)
print('-' * 100)
self._spec = lambda: None
self._spec.id = "Carla-v0"
self.server_port = None
self.server_process = None
self.client = None
self.num_steps = 0
self.total_reward = 0
self.prev_measurement = None
self.prev_image = None
self.episode_id = None
self.measurements_file = None
self.weather = None
self.scenario = None
self.start_pos = None
self.end_pos = None
self.start_coord = None
self.end_coord = None
self.last_obs = None
def __init__(self, level: LevelSelection, seed: int, frame_skip: int,
human_control: bool, custom_reward_threshold: Union[int,
float],
visualization_parameters: VisualizationParameters,
server_height: int, server_width: int, camera_height: int,
camera_width: int, verbose: bool,
experiment_suite: ExperimentSuite, config: str,
episode_max_time: int, allow_braking: bool,
quality: CarlaEnvironmentParameters.Quality,
cameras: List[CameraTypes], weather_id: List[int],
experiment_path: str,
separate_actions_for_throttle_and_brake: bool,
num_speedup_steps: int, max_speed: float, **kwargs):
super().__init__(level, seed, frame_skip, human_control,
custom_reward_threshold, visualization_parameters)
# server configuration
self.server_height = server_height
self.server_width = server_width
self.port = get_open_port()
self.host = 'localhost'
self.map_name = CarlaLevel[level.upper()].value['map_name']
self.map_path = CarlaLevel[level.upper()].value['map_path']
self.experiment_path = experiment_path
# client configuration
self.verbose = verbose
self.quality = quality
self.cameras = cameras
self.weather_id = weather_id
self.episode_max_time = episode_max_time
self.allow_braking = allow_braking
self.separate_actions_for_throttle_and_brake = separate_actions_for_throttle_and_brake
self.camera_width = camera_width
self.camera_height = camera_height
# setup server settings
self.experiment_suite = experiment_suite
self.config = config
if self.config:
# load settings from file
with open(self.config, 'r') as fp:
self.settings = fp.read()
else:
# hard coded settings
self.settings = CarlaSettings()
self.settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=15,
NumberOfPedestrians=30,
WeatherId=random.choice(
force_list(self.weather_id)),
QualityLevel=self.quality.value,
SeedVehicles=seed,
SeedPedestrians=seed)
if seed is None:
self.settings.randomize_seeds()
self.settings = self._add_cameras(self.settings, self.cameras,
self.camera_width,
self.camera_height)
# open the server
self.server = self._open_server()
logging.disable(40)
# open the client
self.game = CarlaClient(self.host, self.port, timeout=99999999)
self.game.connect()
if self.experiment_suite:
self.current_experiment_idx = 0
self.current_experiment = self.experiment_suite.get_experiments()[
self.current_experiment_idx]
self.scene = self.game.load_settings(
self.current_experiment.conditions)
else:
self.scene = self.game.load_settings(self.settings)
# get available start positions
self.positions = self.scene.player_start_spots
self.num_positions = len(self.positions)
self.current_start_position_idx = 0
self.current_pose = 0
# state space
self.state_space = StateSpace({
"measurements":
VectorObservationSpace(
4, measurements_names=["forward_speed", "x", "y", "z"])
})
for camera in self.scene.sensors:
self.state_space[camera.name] = ImageObservationSpace(
shape=np.array([self.camera_height, self.camera_width, 3]),
high=255)
# action space
if self.separate_actions_for_throttle_and_brake:
self.action_space = BoxActionSpace(
shape=3,
low=np.array([-1, 0, 0]),
high=np.array([1, 1, 1]),
descriptions=["steer", "gas", "brake"])
else:
self.action_space = BoxActionSpace(
shape=2,
low=np.array([-1, -1]),
high=np.array([1, 1]),
descriptions=["steer", "gas_and_brake"])
# human control
if self.human_control:
# convert continuous action space to discrete
self.steering_strength = 0.5
self.gas_strength = 1.0
self.brake_strength = 0.5
# TODO: reverse order of actions
self.action_space = PartialDiscreteActionSpaceMap(
target_actions=[[0., 0.], [0., -self.steering_strength],
[0., self.steering_strength],
[self.gas_strength, 0.],
[-self.brake_strength, 0],
[self.gas_strength, -self.steering_strength],
[self.gas_strength, self.steering_strength],
[self.brake_strength, -self.steering_strength],
[self.brake_strength, self.steering_strength]],
descriptions=[
'NO-OP', 'TURN_LEFT', 'TURN_RIGHT', 'GAS', 'BRAKE',
'GAS_AND_TURN_LEFT', 'GAS_AND_TURN_RIGHT',
'BRAKE_AND_TURN_LEFT', 'BRAKE_AND_TURN_RIGHT'
])
# map keyboard keys to actions
for idx, action in enumerate(self.action_space.descriptions):
for key in key_map.keys():
if action == key:
self.key_to_action[key_map[key]] = idx
self.num_speedup_steps = num_speedup_steps
self.max_speed = max_speed
# measurements
self.autopilot = None
self.planner = Planner(self.map_name)
# env initialization
self.reset_internal_state(True)
# render
if self.is_rendered:
image = self.get_rendered_image()
self.renderer.create_screen(image.shape[1], image.shape[0])
def __init__(self,
num_speedup_steps=30,
require_explicit_reset=True,
is_render_enabled=False,
early_termination_enabled=False,
run_offscreen=False,
save_screens=False,
port=2000,
gpu=0,
discrete_control=True,
kill_when_connection_lost=True,
city_name="Town01",
channel_last=True):
EnvironmentWrapper.__init__(self, is_render_enabled, save_screens)
print("port:", port)
self.episode_max_time = 1000000
self.allow_braking = True
self.log_path = os.path.join(DEFAULT_CARLA_LOG_DIR, "CarlaLogs.txt")
self.num_speedup_steps = num_speedup_steps
self.is_game_ready_for_input = False
self.run_offscreen = run_offscreen
self.kill_when_connection_lost = kill_when_connection_lost
# server configuration
self.port = port
self.gpu = gpu
self.host = 'localhost'
self.level = 'town1'
self.map = CarlaLevel().get(self.level)
# experiment = basic_experiment_suite.BasicExperimentSuite(city_name)
experiment = CoRL2017(city_name)
self.experiments = experiment.get_experiments()
self.experiment_type = 0
self.planner = Planner(city_name)
self.car_speed = 0
self.is_game_setup = False # Will be true only when setup_client_and_server() is called, either explicitly, or by reset()
# action space
self.discrete_controls = discrete_control
self.action_space_size = 3
self.action_space_high = np.array([1, 1, 1])
self.action_space_low = np.array([-1, -1, -1])
self.action_space_abs_range = np.maximum(
np.abs(self.action_space_low), np.abs(self.action_space_high))
self.steering_strength = 0.35
self.gas_strength = 1.0
self.brake_strength = 0.6
self.actions = {
0: [0., 0.],
1: [0., -self.steering_strength],
2: [0., self.steering_strength],
3: [self.gas_strength - 0.15, 0.],
4: [-self.brake_strength, 0],
5: [self.gas_strength - 0.3, -self.steering_strength],
6: [self.gas_strength - 0.3, self.steering_strength],
7: [-self.brake_strength, -self.steering_strength],
8: [-self.brake_strength, self.steering_strength]
}
self.actions_description = [
'NO-OP', 'TURN_LEFT', 'TURN_RIGHT', 'GAS', 'BRAKE',
'GAS_AND_TURN_LEFT', 'GAS_AND_TURN_RIGHT', 'BRAKE_AND_TURN_LEFT',
'BRAKE_AND_TURN_RIGHT'
]
if discrete_control:
self.action_space = Discrete(len(self.actions))
else:
self.action_space = Box(low=self.action_space_low,
high=self.action_space_high)
self.observation_space = Box(low=-np.inf,
high=np.inf,
shape=[88, 200, 3])
# measurements
self.measurements_size = (1, )
self.pre_image = None
self.first_debug = True
self.channel_last = channel_last
def __init__(self,
experiment_path=None,
frame_skip=1,
server_height=512,
server_width=720,
camera_height=88,
camera_width=200,
experiment_suite=None,
quality="low",
cameras=[CameraTypes.FRONT],
weather_id=[1],
episode_max_time=30000,
max_speed=35.0,
port=2000,
map_name="Town01",
verbose=True,
seed=None,
is_rendered=True,
num_speedup_steps=30,
separate_actions_for_throttle_and_brake=False,
rendred_image_type='forward_camera'):
self.frame_skip = frame_skip # the frame skip affects the fps of the server directly. fps = 30 / frameskip
self.server_height = server_height
self.server_width = server_width
self.camera_height = camera_height
self.camera_width = camera_width
self.experiment_suite = experiment_suite # an optional CARLA experiment suite to use
self.quality = quality
self.cameras = cameras
self.weather_id = weather_id
self.episode_max_time = episode_max_time # miliseconds for each episode
self.max_speed = max_speed # km/h
self.port = port
self.host = 'localhost'
self.map_name = map_name
self.map_path = map_path_mapper[self.map_name]
self.experiment_path = experiment_path
self.current_episode_steps_counter = 1
# client configuration
self.verbose = verbose
self.episode_idx = 0
self.num_speedup_steps = num_speedup_steps
self.max_speed = max_speed
self.is_rendered = is_rendered
# setup server settings
self.experiment_suite = experiment_suite
self.separate_actions_for_throttle_and_brake = separate_actions_for_throttle_and_brake
self.rendred_image_type = rendred_image_type
self.left_poses = []
self.right_poses = []
self.follow_poses = []
self.Straight_poses = []
self.settings = CarlaSettings()
self.settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=15,
NumberOfPedestrians=30,
WeatherId=self.weather_id,
QualityLevel=self.quality,
SeedVehicles=seed,
SeedPedestrians=seed)
if seed is None:
self.settings.randomize_seeds()
self.settings = self.add_cameras(self.settings, self.cameras,
self.camera_width, self.camera_height)
# open the server
self.server = self.open_server()
logging.disable(40)
print("Successfully opened the server")
# open the client
self.game = CarlaClient(self.host, self.port, timeout=99999999)
print("Successfully opened the client")
self.game.connect()
print("Successfull Connection")
if self.experiment_suite:
self.current_experiment_idx = 0
self.current_experiment = self.experiment_suite.get_experiments()[
self.current_experiment_idx]
self.scene = self.game.load_settings(
self.current_experiment.conditions)
else:
self.scene = self.game.load_settings(self.settings)
# get available start positions
self.positions = self.scene.player_start_spots
self.num_positions = len(self.positions)
self.current_start_position_idx = 0
self.current_pose = 0
self.action_space = ActionSpace(
shape=2,
low=np.array([-1, -1]),
high=np.array([1, 1]),
descriptions=["steer", "gas_and_brake"])
# state space
#define all measurments
self.state_space = {
"measurements": {
"forward_speed": np.array([1]),
"x": np.array([1]),
"y": np.array([1]),
"z": np.array([1])
}
}
#define all cameras
for camera in self.scene.sensors:
self.state_space[camera.name] = {
"data": np.array([self.camera_height, self.camera_width, 3])
}
print("Define ", camera.name, " Camera")
# measurements
self.autopilot = None
self.planner = Planner(self.map_name)
#rendering
if self.is_rendered:
pygame.init()
pygame.font.init()
self.display = pygame.display.set_mode(
(self.camera_width, self.camera_height))
# env initialization
self.reset(True)