def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depends on the selected Town.
"""
# We check the town, based on that we define the town related parameters
# The size of the vector is related to the number of tasks, inside each
# task there is also multiple poses ( start end, positions )
if self._city_name == 'Town01':
poses_tasks = [[[7, 3]], [[138, 17]], [[140, 134]], [[140, 134]]]
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
else:
poses_tasks = [[[4, 2]], [[37, 76]], [[19, 66]], [[19, 66]]]
vehicles_tasks = [0, 0, 0, 15]
pedestrians_tasks = [0, 0, 0, 50]
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
# Based on the parameters, creates a vector with experiment objects.
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather
)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(
Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1
)
experiments_vector.append(experiment)
return experiments_vector
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
if self._city_name == 'Town01':
poses_tasks = self._poses_town01()
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
else:
poses_tasks = self._poses_town02()
vehicles_tasks = [0, 0, 0, 15]
pedestrians_tasks = [0, 0, 0, 50]
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather
)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(
Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1
)
experiments_vector.append(experiment)
return experiments_vector
def _build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(200, 0, 140)
camera.set_rotation(-15.0, 0, 0)
weathers = [1, 3, 6, 8, 4, 14]
if self._city_name == 'Town01':
poses_tasks = self._poses_town01()
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
else:
poses_tasks = self._poses_town02()
vehicles_tasks = [0, 0, 0, 15]
pedestrians_tasks = [0, 0, 0, 50]
experiments_vector = []
for weather in weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather,
SeedVehicles=123456789,
SeedPedestrians=123456789)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Id=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=90)
camera.set_image_size(800, 600)
camera.set_position(1.44, 0.0, 1.2)
camera.set_rotation(0, 0, 0)
if self._city_name == 'Town01':
poses_tasks = self._poses_town01()
vehicles_tasks = [0, 20, 100]
pedestrians_tasks = [0, 50, 250]
else:
poses_tasks = self._poses_town02()
vehicles_tasks = [0, 15, 70]
pedestrians_tasks = [0, 50, 150]
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
conditions.set(DisableTwoWheeledVehicles=True)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
if self._city_name == 'Town01':
poses_tasks = self._poses_town01()
vehicles_tasks = [25]
pedestrians_tasks = [25]
else:
poses_tasks = self._poses_town02()
vehicles_tasks = [0, 25]
pedestrians_tasks = [0, 25]
experiments_vector = []
#weathers = [1,3,6,8]
for weather in self.weathers:
#prinst(weather , vehicles_tasks)
for scenario in range(len(vehicles_tasks)):
for iteration in range(len(poses_tasks)):
#print(f"interation : {iteration} , scenario:{scenario}")
poses = poses_tasks[iteration]
#print("poses re",poses)
vehicles = vehicles_tasks[scenario]
#print("Vehicles: ",vehicles)
pedestrians = pedestrians_tasks[scenario]
#print("pedestrians: ",pedestrians)
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('rgb')
camera.set(FOV=90)
camera.set_image_size(300, 300)
camera.set_position(0.2, 0.0, 0.85)
camera.set_rotation(-3.0, 0, 0)
poses_tasks = self._poses()
vehicles_tasks = [0, 0, 0, 15]
pedestrians_tasks = [0, 0, 0, 50]
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather,
QualityLevel='Epic'
)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(
Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1
)
experiments_vector.append(experiment)
return experiments_vector
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depends on the selected Town.
"""
# We check the town, based on that we define the town related parameters
# The size of the vector is related to the number of tasks, inside each
# task there is also multiple poses ( start end, positions )
if self._city_name == 'Town01':
poses_tasks = [[[7, 150]], [[138, 17]]]
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
else:
poses_tasks = [[[4, 2]], [[37, 76]]]
vehicles_tasks = [0, 0, 0, 15]
pedestrians_tasks = [0, 0, 0, 50]
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
# Based on the parameters, creates a vector with experiment objects.
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
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 build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('rgb')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
poses_tasks = self._poses()
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
task_names = ['straight', 'one_curve', 'navigation', 'navigation_dyn']
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
conditions.set(DisableTwoWheeledVehicles=True)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
TaskName=task_names[iteration],
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
def add_cameras(self, settings, cameras, camera_width, camera_height):
# add a front facing camera
print("Available Cameras are ", cameras)
if CameraTypes.FRONT in cameras:
camera = Camera(CameraTypes.FRONT.value)
camera.set(FOV=100)
camera.set_image_size(camera_width, camera_height)
camera.set_position(2.0, 0, 1.4)
camera.set_rotation(-15.0, 0, 0)
settings.add_sensor(camera)
# add a left facing camera
if CameraTypes.LEFT in cameras:
camera = Camera(CameraTypes.LEFT.value)
camera.set(FOV=100)
camera.set_image_size(camera_width, camera_height)
camera.set_position(2.0, 0, 1.4)
camera.set_rotation(-15.0, -30, 0)
settings.add_sensor(camera)
# add a right facing camera
if CameraTypes.RIGHT in cameras:
camera = Camera(CameraTypes.RIGHT.value)
camera.set(FOV=100)
camera.set_image_size(camera_width, camera_height)
camera.set_position(2.0, 0, 1.4)
camera.set_rotation(-15.0, 30, 0)
settings.add_sensor(camera)
# add a front facing depth camera
if CameraTypes.DEPTH in cameras:
camera = Camera(CameraTypes.DEPTH.value)
camera.set_image_size(camera_width, camera_height)
camera.set_position(0.2, 0, 1.3)
camera.set_rotation(8, 30, 0)
camera.PostProcessing = 'Depth'
settings.add_sensor(camera)
# add a front facing semantic segmentation camera
if CameraTypes.SEGMENTATION in cameras:
camera = Camera(CameraTypes.SEGMENTATION.value)
camera.set_image_size(camera_width, camera_height)
camera.set_position(0.2, 0, 1.3)
camera.set_rotation(8, 30, 0)
camera.PostProcessing = 'SemanticSegmentation'
settings.add_sensor(camera)
print("Successfully adding a SemanticSegmentation camera")
return settings
def _reset(self):
self.num_steps = 0
self.total_reward = 0
self.prev_measurement = None
self.prev_image = None
self.episode_id = datetime.today().strftime("%Y-%m-%d_%H-%M-%S_%f")
self.measurements_file = None
self.pre_intersection = np.array([0.0, 0.0])
# 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()
self.scenario = random.choice(self.config["scenarios"])
assert self.scenario["city"] == self.city, (self.scenario, self.city)
self.weather = random.choice(self.scenario["weather_distribution"])
settings.set(
SynchronousMode=True,
# ServerTimeOut=10000, # CarlaSettings: no key named 'ServerTimeOut'
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=self.scenario["num_vehicles"],
NumberOfPedestrians=self.scenario["num_pedestrians"],
WeatherId=self.weather)
settings.randomize_seeds()
if self.config["use_sensor"] == 'use_semantic':
camera0 = Camera("CameraSemantic",
PostProcessing="SemanticSegmentation")
camera0.set_image_size(self.config["render_x_res"],
self.config["render_y_res"])
# camera0.set_position(30, 0, 130)
camera0.set(FOV=120)
camera0.set_position(2.0, 0.0, 1.4)
camera0.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera0)
if self.config["use_sensor"] in ['use_depth', 'use_logdepth']:
camera1 = Camera("CameraDepth", PostProcessing="Depth")
camera1.set_image_size(self.config["render_x_res"],
self.config["render_y_res"])
# camera1.set_position(30, 0, 130)
camera1.set(FOV=120)
camera1.set_position(2.0, 0.0, 1.4)
camera1.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera1)
if self.config["use_sensor"] == 'use_rgb':
camera2 = Camera("CameraRGB")
camera2.set_image_size(self.config["render_x_res"],
self.config["render_y_res"])
# camera2.set_position(30, 0, 130)
# camera2.set_position(0.3, 0.0, 1.3)
camera2.set(FOV=120)
camera2.set_position(2.0, 0.0, 1.4)
camera2.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera2)
if self.config["use_sensor"] == 'use_2rgb':
camera_l = Camera("CameraRGB_L")
camera_l.set_image_size(self.config["render_x_res"],
self.config["render_y_res"])
camera_l.set(FOV=120)
camera_l.set_position(2.0, -0.1, 1.4)
camera_l.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera_l)
camera_r = Camera("CameraRGB_R")
camera_r.set_image_size(self.config["render_x_res"],
self.config["render_y_res"])
camera_r.set(FOV=120)
camera_r.set_position(2.0, 0.1, 1.4)
camera_r.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera_r)
# Setup start and end positions
scene = self.client.load_settings(settings)
self.positions = positions = scene.player_start_spots
self.start_pos = positions[self.scenario["start_pos_id"]]
self.pre_pos = self.start_pos.location
self.cnt1 = 0
self.displacement = 1000.0
self.end_pos = positions[self.scenario["end_pos_id"]]
self.start_coord = [
self.start_pos.location.x // 1, self.start_pos.location.y // 1
]
self.end_coord = [
self.end_pos.location.x // 1, self.end_pos.location.y // 1
]
print("Start pos {} ({}), end {} ({})".format(
self.scenario["start_pos_id"], self.start_coord,
self.scenario["end_pos_id"], self.end_coord))
# 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...")
self.client.start_episode(self.scenario["start_pos_id"])
# remove the vehicle dropping when starting a new episode.
cnt = 1
z1 = 0
zero_control = VehicleControl()
while (cnt < 3):
self.client.send_control(
zero_control
) # VehicleControl().steer = 0, VehicleControl().throttle = 0, VehicleControl().reverse = False
z0 = z1
z1 = self.client.read_data(
)[0].player_measurements.transform.location.z
print(z1)
if z0 - z1 == 0:
cnt += 1
print('Starting new episode done.\n')
# Process observations: self._read_observation() returns image and py_measurements.
image, py_measurements = self._read_observation()
self.prev_measurement = py_measurements
# self.current_heading = self.pre_heading = np.array([py_measurements["x_orient"], py_measurements["y_orient"]])
# self.angular_speed = 0.0
self.pre_heading_degree = self.current_heading_degree = py_measurements[
"current_heading_degree"]
self.angular_speed_degree = np.array(0.0)
return self.encode_obs(self.preprocess_image(image),
py_measurements), py_measurements
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
if self._task == 'go-straight':
task_select = 0
elif self._task == 'turn-right':
task_select = 1
elif self._task == 'turn-left':
task_select = 2
elif self._task == 'go-straight-2':
task_select = 3
elif self._task == 'turn-right-2':
task_select = 4
elif self._task == 'turn-left-2':
task_select = 5
if self._city_name == 'Town01':
poses_tasks = self._poses_town01()
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
elif self._city_name == 'Town02':
poses_tasks = self._poses_town02()
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
elif self._city_name[:-1] == 'Town01_nemesis':
poses_tasks = [self._poses_town01_nemesis()[task_select]]
vehicles_tasks = [0, 0, 0, 0, 0, 0]
pedestrians_tasks = [0, 0, 0, 0, 0, 0]
elif self._city_name[:-1] == 'Town02_nemesis':
poses_tasks = [self._poses_town02_nemesis()[task_select]]
vehicles_tasks = [0, 0, 0, 0, 0, 0]
pedestrians_tasks = [0, 0, 0, 0, 0, 0]
experiments_vector = []
"""repeating experiment"""
num_iters = self._iters
weathers_iters = [self._weather] * num_iters
# 0 - Default
# 1 - ClearNoon
# 2 - CloudyNoon
# 3 - WetNoon
# 4 - WetCloudyNoon
# 5 - MidRainyNoon
# 6 - HardRainNoon
# 7 - SoftRainNoon
# 8 - ClearSunset
# 9 - CloudySunset
# 10 - WetSunset
# 11 - WetCloudySunset
# 12 - MidRainSunset
# 13 - HardRainSunset
# 14 - SoftRainSunset
for weather in weathers_iters:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
## add here
# random the scenario
#weather_num_random = int(random.uniform(0,14))
#vehicles_num_random = int(random.uniform(0,1000))
#pedestrain_num_random = int(random.uniform(0,1000))
#vehicles = vehicles_num_random
#pedestrains = pedestrain_num_random
#weather = weather_num_random
vehicles = 400
pedestrains = 400
#weather =
##
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
def _reset(self):
self.num_steps = 0
self.total_reward = 0
self.prev_measurement = None
self.prev_image = None
self.episode_id = datetime.today().strftime("%Y-%m-%d_%H-%M-%S_%f")
self.measurements_file = 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()
self.scenario = random.choice(self.config["scenarios"])
assert self.scenario["city"] == self.city, (self.scenario, self.city)
self.weather = random.choice(self.scenario["weather_distribution"])
settings.set(
SynchronousMode=True,
# ServerTimeOut=10000, # CarlaSettings: no key named 'ServerTimeOut'
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=self.scenario["num_vehicles"],
NumberOfPedestrians=self.scenario["num_pedestrians"],
WeatherId=self.weather)
settings.randomize_seeds()
if self.config["use_depth_camera"]:
camera1 = Camera("CameraDepth", PostProcessing="Depth")
camera1.set_image_size(self.config["render_x_res"],
self.config["render_y_res"])
# camera1.set_position(30, 0, 130)
camera1.set(FOV=120)
camera1.set_position(2.0, 0.0, 1.4)
camera1.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera1)
camera2 = Camera("CameraRGB")
camera2.set_image_size(self.config["render_x_res"],
self.config["render_y_res"])
# camera2.set_position(30, 0, 130)
# camera2.set_position(0.3, 0.0, 1.3)
camera2.set(FOV=120)
camera2.set_position(2.0, 0.0, 1.4)
camera2.set_rotation(0.0, 0.0, 0.0)
settings.add_sensor(camera2)
# Setup start and end positions
scene = self.client.load_settings(settings)
positions = scene.player_start_spots
self.start_pos = positions[self.scenario["start_pos_id"]]
self.end_pos = positions[self.scenario["end_pos_id"]]
self.start_coord = [
self.start_pos.location.x // 100, self.start_pos.location.y // 100
]
self.end_coord = [
self.end_pos.location.x // 100, self.end_pos.location.y // 100
]
print("Start pos {} ({}), end {} ({})".format(
self.scenario["start_pos_id"], self.start_coord,
self.scenario["end_pos_id"], self.end_coord))
# 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...")
self.client.start_episode(self.scenario["start_pos_id"])
# Process observations: self._read_observation() returns image and py_measurements.
image, py_measurements = self._read_observation()
self.prev_measurement = py_measurements
return self.encode_obs(self.preprocess_image(image), py_measurements)
def run_carla_client(args, classifier, plt, plt_index):
global global_steering_indicator
# Here we will run 3 episodes with 300 frames each.
frames_per_episode = args.frames
if args.position:
number_of_episodes = 1
else:
number_of_episodes = 3
# 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=0,
NumberOfPedestrians=0,
WeatherId=random.choice([2]),
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(256, 256)
# # Set its position relative to the car in meters.
# camera0.set_position(2.2, 0, 1.30)
# settings.add_sensor(camera0)
if args.lidar:
# Adding a lidar sensor
lidar = Lidar('Lidar32')
lidar.set_position(0, 0, 2.50)
lidar.set_rotation(0, 0, 0)
lidar.set(
Channels=32,
Range=50,
PointsPerSecond=args.lidar_pps,
RotationFrequency=10,
UpperFovLimit=10,
LowerFovLimit=-30)
settings.add_sensor(lidar)
else:
# Let's add another camera producing ground-truth depth.
camera1 = Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(256, 256)
camera1.set_position(2.2, 0, 1.30)
camera1.set(FOV=90.0)
#camera1.set_rotation(pitch=-8, yaw=0, roll=0)
settings.add_sensor(camera1)
camera2 = Camera('CameraSeg', PostProcessing='SemanticSegmentation')
camera2.set_image_size(256, 256)
camera2.set_position(2.2, 0, 1.30)
camera2.set(FOV=90.0)
#camera2.set_rotation(pitch=-8, yaw=0, roll=0)
settings.add_sensor(camera2)
if args.capture:
camera3 = Camera('CameraRGB')
camera3.set_image_size(512, 256)
camera3.set_position(-8, 0, 5)
camera3.set(FOV=90.0)
camera3.set_rotation(pitch=-20, yaw=0, roll=0)
settings.add_sensor(camera3)
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)
if args.position:
player_start = args.position
else:
player_start = random.choice([42,67,69,79,94,97, 70, 44,85,102])
# 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)
""" Begin added code """
if args.capture:
directory = '_capture/pos{}'.format(player_start)
if not os.path.exists(directory):
os.makedirs(directory)
print("Capturing point clouds to {}".format(directory))
""" End added code """
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()
""" Begin added code """
# dict of steering directions of available curves
# [1,0] if the next curve will be a left one
# [0,1] if the next curve will be a right one
directions = {
67: [[1,0]], # straight
42: [[1,0]], # straight or left
69: [[0,1]], # right
79: [[0,1]], # right
94: [[0,1]], # right
97: [[0,1]], # right
70: [[1,0]], # left
44: [[1,0]], # left
85: [[1,0]], # left
102: [[1,0]] # left
}
#dynamically set the global steering indicator during the game
if(args.key_control):
set_steering_indicator_from_keypress()
steering_direction = args.steering_indicator or global_steering_indicator
if args.use_steering_indicator:
if steering_direction == "left":
steering_indicator = [[1,0]]
elif steering_direction == "right":
steering_indicator = [[0,1]]
else:
steering_indicator = [[0,0]]
steering_indicator = torch.Tensor(steering_indicator)
if cuda_available:
steering_indicator = steering_indicator.cuda()
if args.lidar:
point_cloud = sensor_data['Lidar32'].data
if args.lidar_fov == 180:
print("FOV 180")
print("Before", point_cloud.shape)
point_cloud = filter_fov(point_cloud)
print("After", point_cloud.shape)
else:
# Get depth and seg as numpy array for further processing
depth_obj = sensor_data['CameraDepth']
depth = depth_obj.data
fov = depth_obj.fov
# Filter seg to get intersection points
seg = sensor_data['CameraSeg'].data
filtered_seg = pp.filter_seg_image(seg)
# Add following lines to measure performance of generating pointcloud
# def f():
# return pp.depth_to_local_point_cloud(depth, fov, filtered_seg)
# print(timeit.timeit(f, number=1000) / 1000)
# Create pointcloud from seg and depth (but only take intersection points)
point_cloud = pp.depth_to_local_point_cloud(depth, fov, filtered_seg)
# Save point cloud for later visualization
if args.capture:
pp.save_to_disk(point_cloud, "{}/point_clouds/point_cloud_{:0>5d}.ply".format(directory, frame))
sensor_data['CameraRGB'].save_to_disk('{}/images/image_{:0>5d}.png'.format(directory, frame))
# Normalizing the point cloud
if not args.no_center or not args.no_norm:
point_cloud = point_cloud - np.expand_dims(np.mean(point_cloud, axis=0), 0) # center
if not args.no_norm:
dist = np.max(np.sqrt(np.sum(point_cloud ** 2, axis=1)), 0)
point_cloud = point_cloud / dist # scale
#pp.save_point_cloud(point_cloud, 'test')
# pp.save_seg_image(filtered_seg)
""" End added code """
# 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.
""" Beginn added code """
control = measurements.player_measurements.autopilot_control
#steer = control.steer
#print(control)
point_cloud = point_cloud.transpose()
points = np.expand_dims(point_cloud, axis=0)
points = torch.from_numpy(points.astype(np.float32))
#print(points)
if cuda_available:
points = points.cuda()
classifier = classifier.eval()
if args.use_steering_indicator:
#print("Using PointNetReg2")
steer, _, _ = classifier((points, steering_indicator))
else:
#print("Using PointNetReg")
steer, _, _ = classifier(points)
steer = steer.item()
if args.use_steering_indicator:
print("Using steering indicator: {} / {}".format(steering_direction, steering_indicator))
print("Autopilot steer: ", control.steer)
print("Pointnet steer: ", steer)
print("Relative difference: ", steer / control.steer if control.steer != 0.0 else 'NaN')
print("Absolute difference: ", control.steer - steer)
print("FOV:", args.lidar_fov)
# Plot some visualizations to visdom
if args.visdom:
plt.plot_point_cloud(points, var_name='pointcloud')
plt.plot('steering', 'PointNet', 'Steering', plt_index, steer)
plt.plot('steering', 'Autopilot', 'Steering', plt_index, control.steer)
plt_index += 1
# Let pointnet take over steering control
if True:
print("Who's in command: POINTNET")
control.steer = steer
if args.ignore_red_lights or args.use_steering_indicator:
control.throttle = 0.5
control.brake=0.0
hand_brake=False
else:
print("Who's in command: AUTOPILOT")
print("_________")
#pdb.set_trace()
""" End added code """
client.send_control(control)
def run_carla_client(args,
number_of_episodes=10,
frames_per_episode=500,
starting_episode=0):
with make_carla_client("localhost", 2000) as client:
print('carla client connected')
# setting up data type
imitation_type = np.dtype([('image', np.uint8, (512, 512, 3)),
('label', np.float32, 5)])
print("datatype :\n{}".format(imitation_type))
# total frames collected this run
total_frames = 0
for episode in range(starting_episode, number_of_episodes):
# flag to skip the initial frames where the car doesn't move
record = False
# settings
settings = CarlaSettings()
if args.settings_filepath is None:
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=1, # clear noon
QualityLevel='Low') # QualityLevel=args.quality_level
settings.randomize_seeds()
camera = Camera('RGBFront', PostProcessing='SceneFinal')
camera.set_image_size(512, 512)
camera.set(FOV=120.0)
# camera.set_position(1.65, 0, 1.30) < OLD
camera.set_position(2.0, 0, 1.60)
camera.set_rotation(roll=0, pitch=-10, yaw=0)
settings.add_sensor(camera)
else:
# load settings from file
with open(args.settings_filepath, 'r') as fp:
settings = fp.read()
# choosing starting position, starting episode
scene = client.load_settings(settings)
number_of_player_starts = len(scene.player_start_spots)
# going through them one by one
player_start = episode % number_of_player_starts
print("starting new episode ({})... {} frames saved".format(
episode, total_frames))
client.start_episode(player_start)
# keeping track of the frames that are actually being saved
frame_index = 0
# new episode, new dataset
dataset = hdf5_file.create_dataset("episode_{}".format(episode),
shape=(1, ),
maxshape=(None, ),
chunks=(1, ),
compression="lzf",
dtype=imitation_type)
# execute frames
for frame in range(0, frames_per_episode):
measurements, sensor_data = client.read_data()
if frame == 0:
initial_pose = measurements.player_measurements.transform.location
elif not record:
distance = distance_3d(
initial_pose,
measurements.player_measurements.transform.location)
record = distance > 1.5
else:
frame_index += 1
# print_measurements(measurements)
for name, measurement in sensor_data.items():
if record and args.save_images_to_disk:
filename = "{}_e{}_f{:02d}".format(
name, episode, frame_index)
measurement.save_to_disk(
os.path.join("./data", filename))
# getting autopilot controls
control = measurements.player_measurements.autopilot_control
# SDL_VIDEODRIVER = offscreen
if record:
label = np.ndarray(shape=(5, ), dtype=float)
control.steer = control.steer if np.abs(
control.steer) > 5e-4 else 0
label[0] = control.steer
label[1] = control.throttle
label[2] = control.brake
label[3] = 1 if control.hand_brake else 0
label[4] = 1 if control.reverse else 0
frame = sensor_data['RGBFront'].data
frame = np.transpose(frame, (1, 0, 2))
data = np.array([(frame, label)], dtype=imitation_type)
dataset.resize(frame_index + 2, axis=0)
dataset[frame_index] = data
total_frames += 1
client.send_control(control)
def create_settings(n_vehicles, n_pedestrians, quality_level,
image_size, use_lidar, root_dir, lidar_params, z_BEV=25):
# 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()
# Make sure that the server is running with '-benchmark' flag
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=n_vehicles,
NumberOfPedestrians=n_pedestrians,
# WeatherId=4,
WeatherId=1,
# WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel=quality_level)
settings.randomize_seeds()
log.info("Vehicle seed: {}".format(settings.SeedVehicles))
# TODO make lidar params pay attention to the H x W of BEV?
settings.lidar_params = lidar_params
# 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.
front_cam_rgb = Camera('CameraRGB')
front_cam_position = (0., 0., 1.5)
# angel_cam_position = (-5.5, 0.0, 2.8)
# angel_cam_position = (-5.5, 0.0, 3.8)
angel_cam_position = (-7.5, 0.0, 4.8)
# For visualization.
front_cam_rgb.FOV = 90
# Set image resolution in pixels.
front_cam_rgb.set_image_size(*image_size)
# Set its position relative to the car in meters.
# Default forward-facing
# camera0.set_position(0.30, 0, 1.30)
# front_cam_rgb.set_position(*front_cam_position)
front_cam_rgb.set_position(*angel_cam_position)
# front_cam_rgb.set_rotation(roll=0., pitch=-15., yaw=0.0)
front_cam_rgb.set_rotation(roll=0., pitch=-15., yaw=0.0)
settings.add_sensor(front_cam_rgb)
# Bird's eye view.
bev_cam_rgb = Camera('CameraRGBBEV')
# Note that at FOV=90, image width across ground plane is z*2 (if camera is parallel to ground)
# z_BEV = 50
bev_cam_rgb.set_position(x=0, y=0, z=z_BEV)
bev_cam_rgb.set_rotation(pitch=-90, roll=0, yaw=-90)
bev_cam_rgb.set_image_size(400, 400)
# bev_cam_rgb.set_image_size(200, 200)
# bev_cam_rgb.set_image_size(*image_size)
settings.add_sensor(bev_cam_rgb)
# bev_cam_sem = Camera('CameraSemanticBEV', PostProcessing='SemanticSegmentation')
# # Note that at FOV=90, image width across ground plane is z*2 (if camera is parallel to ground)
# bev_cam_sem.set_position(x=0, y=0, z=z_BEV)
# bev_cam_sem.set_rotation(pitch=-90, roll=0, yaw=0)
# bev_cam_sem.set_image_size(*image_size)
# settings.add_sensor(bev_cam_sem)
# Let's add another camera producing ground-truth depth.
front_cam_depth = Camera('CameraDepth', PostProcessing='Depth')
front_cam_depth.set_image_size(*image_size)
front_cam_depth.set_position(*front_cam_position)
settings.add_sensor(front_cam_depth)
# Semantic segmentation is black! Even in the demo code of manual_control.py ... Might be an issue with graphics card / Unreal support?
# See https://github.com/carla-simulator/carla/issues/151
camera = Camera('CameraSemantic', PostProcessing='SemanticSegmentation')
camera.set(FOV=90.0)
camera.set_image_size(*image_size)
camera.set_position(*front_cam_position)
camera.set_rotation(pitch=0, yaw=0, roll=0)
settings.add_sensor(camera)
if use_lidar:
settings.add_sensor(create_lidar())
else:
log.info("Not adding lidar")
return settings
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
if self._city_name == 'Town01':
if self._subset == 'keep_lane':
poses_tasks = [self._poses_town01()[0]]
vehicles_tasks = [0]
pedestrians_tasks = [0]
elif self._subset == 'one_turn':
poses_tasks = [self._poses_town01()[1]]
vehicles_tasks = [0]
pedestrians_tasks = [0]
elif self._subset == 'keep_lane_one_turn':
poses_tasks = self._poses_town01()[:2]
vehicles_tasks = [0, 0]
pedestrians_tasks = [0, 0]
elif self._subset == 'no_dynamic_objects':
poses_tasks = self._poses_town01()[:3]
vehicles_tasks = [0, 0, 0]
pedestrians_tasks = [0, 0, 0]
elif self._subset is None:
poses_tasks = self._poses_town01()
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
else:
raise ValueError(
"experiments-subset must be keep_lane or keep_lane_one_turn or no_dynamic_objects or None"
)
else:
raise ValueError("city must be Town01 for training")
experiments_vector = []
for i, iteration in enumerate(range(len(poses_tasks))):
for weather in self.weathers:
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
def run_carla_client(args):
# Here we will run 3 episodes with 300 frames each.
number_of_episodes = 1
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]),
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(800, 600)
# Set its position relative to the car in meters.
camera0.set_position(0.30, 0, 1.30)
settings.add_sensor(camera0)
############# GETTING RIGHT CAMERA IMAGES
camera2 = Camera('CameraRGBRight')
# Set image resolution in pixels.
camera2.set_image_size(800, 600)
# Set its position relative to the car in meters.
camera2.set_position(-1.30, 1.30, 1.30)
camera2.set_rotation(pitch=0, yaw=90, roll=0)
settings.add_sensor(camera2)
#############
############# GETTING LEFT CAMERA IMAGES
camera2 = Camera('CameraRGBLeft')
# Set image resolution in pixels.
camera2.set_image_size(800, 600)
# Set its position relative to the car in meters.
camera2.set_position(-1.30, -1.30, 1.30)
camera2.set_rotation(pitch=0, yaw=270, roll=0)
settings.add_sensor(camera2)
#############
# 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)
if args.semantic:
semcamera = Camera('SemanticSegmentation',
PostProcessing='SemanticSegmentation')
semcamera.set(FOV=90.0)
semcamera.set_image_size(800, 600)
semcamera.set_position(x=0.30, y=0, z=1.30)
semcamera.set_rotation(pitch=0, yaw=0, roll=0)
settings.add_sensor(semcamera)
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...')
client.start_episode(player_start)
# list to hold measurements per frame for one episode
ep_msg = []
# 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.
msg = 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)
# writing measurements as np array
ep_msg.append(msg)
# 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)
# Write measurement data of one episode to file
import os
if not os.path.isdir('_out/measurements'):
os.mkdir('_out/measurements')
fname = "_out/measurements/" + str(episode) + ".txt"
f = open(fname, "w+")
for line in ep_msg:
f.write(line)
f.write("\n")
f.close()
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
if self._city_name == 'Town01':
poses_tasks = self._poses_town01()
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
elif self._city_name == 'Town02':
poses_tasks = self._poses_town02()
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
elif self._city_name == 'Town01_nemesis':
poses_tasks = self._poses_town01_nemesis()
vehicles_tasks = [0, 0, 0, 0]
pedestrians_tasks = [0, 0, 0, 0]
elif self._city_name == 'Town02_nemesis':
poses_tasks = self._poses_town02_nemesis()
vehicles_tasks = [0, 0, 0, 0]
pedestrians_tasks = [0, 0, 0, 0]
elif self._city_name == 'Town01_mini':
poses_tasks = self._poses_town01_mini()
vehicles_tasks = [0, 0, 0, 0]
pedestrians_tasks = [0, 0, 0, 0]
experiments_vector = []
"""repeating experiment"""
num_iters = 171
weathers_iters = [1] * num_iters
for weather in weathers_iters:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
def run_carla_client(args):
# Settings
# Town 1
## Natural turns: [42,67,69,79,94,97,70,44,85,102], [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]
## T-intersection: [88,90,107,133,136]
## Side intersection left: [ 66, 16, 25 ]
## Side intersection right: [ 138, 19, 26 ]
## Staight: [14, 149, 78, 71, 89]
# Town 2
## Natural turns right: [65, 78, 44, 1]
## Natural turns left: [49, 50, 57, 70]
## T-intersection [2, 5, 10, 11, 19, 26, 34, 37]
## Side intersection left: [7, 23, 16, 39, 6, 43, 79]
## Side intersection right: [40, 20, 28, 32, 34, 46, 71, 74]
## Straight: [61, 64, 77, 51]
positions = args.positions or [65, 78, 49, 50, 2, 5, 10, 7, 23, 40, 20, 61]
levels_of_randomness = args.randomness or [0.0, 0.2, 0.4, 0.6]
frames_per_level = args.frames or [
200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200
]
print("Positions: ", positions)
print("Levels of randomness: ", levels_of_randomness)
print("Frames per level: ", frames_per_level)
# 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')
directions = ["_left", "_right"
] if args.force_left_and_right else ["_"]
for direction in directions:
print("Direction ", direction)
# 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()
direction_var = 6 if direction == "_right" else 0
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=0,
NumberOfPedestrians=0,
WeatherId=random.choice([2]),
QualityLevel=args.quality_level,
SeedVehicles=direction_var)
#settings.randomize_seeds()
if args.capture:
# To create visualisation of the current run
camera3 = Camera('CameraRGB')
camera3.set_image_size(512, 256)
camera3.set_position(-8, 0, 5)
camera3.set(FOV=args.fov)
camera3.set_rotation(pitch=-20, yaw=0, roll=0)
settings.add_sensor(camera3)
# Now we want to add a couple of cameras to the player vehicle.
# We will collect the images produced by these cameras every
# frame.
if args.point_cloud:
# Camera to produce point Cloud
camera1 = Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(256, 256)
camera1.set_position(2.2, 0, 1.30)
camera1.set(FOV=args.fov)
settings.add_sensor(camera1)
camera2 = Camera('CameraSeg',
PostProcessing='SemanticSegmentation')
camera2.set_image_size(256, 256)
camera2.set_position(2.2, 0, 1.30)
camera2.set(FOV=args.fov)
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)
# 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)
# 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.
for episode, position in enumerate(positions):
for randomness, frames in zip(levels_of_randomness,
frames_per_level):
crashed = True
while crashed:
crashed = False
# Start a new episode.
print('Starting new episode at %r...' % scene.map_name)
print('Episode {}, Position {}, Randomness {}'.format(
episode, position, randomness))
client.start_episode(position)
if args.capture:
# Make sure directories exist
directory = '_out/pos{}{}/randomness_{}'.format(
position, direction, randomness)
ply_dir = '{}/point_clouds'.format(directory)
ply_dir_full = '{}/point_clouds_full'.format(
directory)
lidar_dir = '{}/lidar'.format(directory)
img_dir = '{}/images'.format(directory)
if not os.path.exists(img_dir):
os.makedirs(img_dir)
if args.point_cloud and not os.path.exists(
ply_dir):
os.makedirs(ply_dir)
if args.point_cloud and not os.path.exists(
ply_dir_full):
os.makedirs(ply_dir_full)
if args.lidar and not os.path.exists(lidar_dir):
os.makedirs(lidar_dir)
# Write steering data to csv file
if args.point_cloud:
csv = open(
"{}/driving_data.csv".format(ply_dir), "w")
elif args.lidar:
csv = open(
"{}/driving_data.csv".format(lidar_dir),
"w")
csv.write(",name,speed,throttle,steer\n")
# Iterate every frame in the episode
for frame in tqdm(range(frames)):
# Read the data produced by the server this frame.
measurements, sensor_data = client.read_data()
if args.capture:
if args.point_cloud:
# Save processed point clouds and autopilot steering to disk if requested
# Get depth and seg as numpy array for further processing
depth_obj = sensor_data['CameraDepth']
depth = depth_obj.data
fov = depth_obj.fov
# Filter seg to get intersection points
seg = sensor_data['CameraSeg'].data
filtered_seg = pp.filter_seg_image(seg)
if args.full_point_cloud:
# Converting depth image to grayscale
point_cloud_full = pp.depth_to_local_point_cloud(
depth,
fov,
seg,
max_depth=0.05,
full=True)
filename_full = "point_cloud_full_{:0>5d}".format(
frame)
pp.save_to_disk(
point_cloud_full,
"{}/{}.ply".format(
ply_dir_full, filename_full))
# Create pointcloud from seg and depth (but only take intersection points)
point_cloud = pp.depth_to_local_point_cloud(
depth,
fov,
filtered_seg,
max_depth=0.05)
filename = "point_cloud_{:0>5d}".format(
frame)
pp.save_to_disk(
point_cloud,
"{}/{}.ply".format(ply_dir, filename))
if args.lidar:
sensor_data['Lidar32'].save_to_disk(
'{}/point_cloud_{:0>5d}'.format(
lidar_dir, frame))
# Save steering data of this frame
control = measurements.player_measurements.autopilot_control
csv.write("0,image_{:0>5d},0,0,{}\n".format(
frame, control.steer))
# Save rgb image to visualize later
sensor_data['CameraRGB'].save_to_disk(
'{}/image_{:0>5d}.png'.format(
img_dir, 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.
control = measurements.player_measurements.autopilot_control
speed = measurements.player_measurements.forward_speed
old_steer = control.steer
control.steer += random.uniform(
-randomness, randomness)
if args.ignore_red_lights:
control.throttle = 0.5
control.brake = 0.0
control.hand_brake = False
control.reverse = False
client.send_control(control)
crashed = False
if speed < 1 and abs(old_steer) > 0.5:
print(
"\nSeems like we crashed.\nTrying again..."
)
crashed = True
break
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depends on the selected Town.
"""
# We check the town, based on that we define the town related parameters
# The size of the vector is related to the number of tasks, inside each
# task there is also multiple poses ( start end, positions )
if self._city_name == 'Town01':
#poses_tasks = [[[7, 3]], [[138, 17]], [[140, 134]], [[140, 134]]]
poses_tasks = [[[138, 134]]]
vehicles_tasks = [20]
pedestrians_tasks = [10]
else:
right_curves = [[[1, 56], [65, 69], [78, 51], [44, 61], [40, 17],
[71, 16], [74, 38], [46, 12], [19, 18], [26, 74],
[37, 76], [11, 44], [20, 6], [10, 22], [28, 2],
[5, 15], [14, 33], [34, 8]]]
left_curves = [[[57, 82], [72, 43], [52, 79], [70, 66], [43, 14],
[11, 47], [79, 32], [37, 75], [75, 16], [26, 73],
[39, 5], [2, 37], [34, 13], [6, 35], [10, 19],
[23, 6], [5, 30], [16, 2]]]
special_test = [[[19, 66], [79, 14], [42, 13], [31, 71], [54, 30],
[10, 61], [66, 3], [27, 12], [2, 29], [16, 14],
[70, 73], [46, 67], [51, 81], [56, 65], [43, 54]]]
corl_task2 = [[[19, 66], [79, 14], [19, 57], [23, 1], [53, 76],
[42, 13], [31, 71], [33, 5], [54, 30], [10, 61],
[66, 3], [27, 12], [79, 19], [2, 29], [16, 14],
[5, 57], [70, 73], [46, 67], [57, 50], [61, 49],
[21, 12], [51, 81], [77, 68], [56, 65], [43, 54]]]
#poses_tasks = corl_task2
poses_tasks = [[[10, 19]]]
vehicles_tasks = [0] #*len(poses_tasks[0])
pedestrians_tasks = [0] #*len(poses_tasks[0])
# We set the camera
# This single RGB camera is used on every experiment
'''camera = Camera('CameraRGB')
camera.set(FOV=90)
camera.set_image_size(800, 600)
camera.set_position(1.44, 0.0, 1.2)
camera.set_rotation(0, 0, 0)'''
camera0 = Camera('CameraRGB0')
camera0.set(FOV=90)
camera0.set_image_size(400, 300)
camera0.set_position(1.7, 0.0, 1.3)
camera0.set_rotation(0, 0, 0)
camera1 = Camera('CameraRGB1')
camera1.set(FOV=90)
camera1.set_image_size(400, 300)
camera1.set_position(1.7, 0.0, 1.3)
camera1.set_rotation(0, -45, 0)
camera2 = Camera('CameraRGB2')
camera2.set(FOV=90)
camera2.set_image_size(400, 300)
camera2.set_position(1.7, 0.0, 1.3)
camera2.set_rotation(0, +45, 0)
# Based on the parameters, creates a vector with experiment objects.
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera0)
conditions.add_sensor(camera1)
conditions.add_sensor(camera2)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
'''path0=os.listdir('CameraRGB0')
path1=os.listdir('CameraRGB1')
path2=os.listdir('CameraRGB2')
os.mkdir('CameraRGB')
width=400
height=300
total_width = width*3
max_height = height
i = 0
images=[]
images.append(Image.open('CameraRGB1/'+path1[i]))
images.append(Image.open('CameraRGB0/'+path0[i]))
images.append(Image.open('CameraRGB2/'+path2[i]))
new_im = Image.new('RGB', (total_width, max_height))
x_offset = 0
for im in images:
new_im.paste(im, (x_offset,0))
x_offset += im.size[0]
new_im.save('CameraRGB/'+path0[i])
i = i+1'''
return experiments_vector
def build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depend on the selected Town.
"""
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraMiddle')
camera.set(FOV=90)
camera.set_image_size(768, 576)
camera.set_position(1.5, 0.0, 1.6)
camera.set_rotation(0, 0, 0)
if self._city_name == 'Town01':
poses_tasks = self._poses_town01()
vehicles_tasks = [0, 0, 0, 100]
pedestrians_tasks = [0, 0, 0, 300]
n_samples = [0, 0, 30 // 4, 60 // 4]
#n_samples = [3, 6, 6, 9]
else:
poses_tasks = self._poses_town02()
vehicles_tasks = [0, 0, 0, 50]
pedestrians_tasks = [0, 0, 0, 150]
n_samples = [0, 0, 15, len(poses_tasks[-1])]
#n_samples = [3, 6, 6, 9]
experiments_vector = []
random.seed(1)
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
nsample = n_samples[iteration]
if nsample == 0:
continue
poses = random.sample(poses, nsample)
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather,
QualityLevel="Low")
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1)
experiments_vector.append(experiment)
return experiments_vector
def build_eccv_navigation_dynamic():
def _poses_town01():
"""
Each matrix is a new task. We have all the four tasks
"""
def _poses_navigation():
return [[36, 40], [39, 35]]
#return [[105, 29], [27, 130], [102, 87], [132, 27], [24, 44],
# [96, 26], [34, 67], [28, 1], [140, 134], [105, 9],
# [148, 129], [65, 18], [21, 16], [147, 97], [42, 51],
# [30, 41], [18, 107], [69, 45], [102, 95], [18, 145],
# [111, 64], [79, 45], [84, 69], [73, 31], [37, 81]]
return [_poses_navigation()]
def _poses_town02():
def _poses_navigation():
return [[38, 34], [4, 2]]
#return [[19, 66], [79, 14], [19, 57], [23, 1],
# [53, 76], [42, 13], [31, 71], [33, 5],
# [54, 30], [10, 61], [66, 3], [27, 12],
# [79, 19], [2, 29], [16, 14], [5, 57],
# [70, 73], [46, 67], [57, 50], [61, 49], [21, 12],
# [51, 81], [77, 68], [56, 65], [43, 54]]
return [_poses_navigation()]
# We check the town, based on that we define the town related parameters
# The size of the vector is related to the number of tasks, inside each
# task there is also multiple poses ( start end, positions )
exp_set_dict = {
'Name': 'eccv_navigation_dynamic',
'Town01': {'poses': _poses_town01(),
'vehicles': [20],
'pedestrians': [50],
'weathers_train': [1],
'weathers_validation': []
},
'Town02': {'poses': _poses_town02(),
'vehicles': [15],
'pedestrians': [50],
'weathers_train': [],
'weathers_validation': [14]
}
}
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('rgb')
camera.set(FOV=100)
camera.set_image_size(800, 600)
camera.set_position(2.0, 0.0, 1.4)
camera.set_rotation(-15.0, 0, 0)
sensor_set = [camera]
return _build_experiments(exp_set_dict, sensor_set), exp_set_dict
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 build_experiments(self):
"""
Creates the whole set of experiment objects,
The experiments created depends on the selected Town.
"""
# We check the town, based on that we define the town related parameters
# The size of the vector is related to the number of tasks, inside each
# task there is also multiple poses ( start end, positions )
if self._city_name == 'Town01':
poses_tasks = [[[7, 3]], [[138, 17]], [[140, 134]], [[140, 134]]]
vehicles_tasks = [0, 0, 0, 20]
pedestrians_tasks = [0, 0, 0, 50]
else:
right_curves = [[[1,56],[65,69],[78,51],[44,61],[40,17],[71,16],[74,38],[46,12],
[19,18],[26,74],[37,76],[11,44],[20,6],[10,22],[28,2],[5,15],
[14,33],[34,8]]]
left_curves = [[[57,82],[72,43],[52,79],[70,66],[43,14],[11,47],[79,32],[37,75],
[75,16],[26,73],[39,5],[2,37],[34,13],[6,35],[10,19],[23,6],
[5,30],[16,2]]]
special_test = [[[19, 66], [79, 14],[42, 13], [31, 71],
[54, 30], [10, 61], [66, 3], [27, 12],
[2, 29], [16, 14],[70, 73], [46, 67],
[51, 81], [56, 65], [43, 54]]]
corl_task2 = [[[19, 66], [79, 14], [19, 57], [23, 1],
[53, 76], [42, 13], [31, 71], [33, 5],
[54, 30], [10, 61], [66, 3], [27, 12],
[79, 19], [2, 29], [16, 14], [5, 57],
[70, 73], [46, 67], [57, 50], [61, 49], [21, 12],
[51, 81], [77, 68], [56, 65], [43, 54]]]
poses_tasks = corl_task2
vehicles_tasks = [0]*len(poses_tasks[0])
pedestrians_tasks = [0]*len(poses_tasks[0])
# We set the camera
# This single RGB camera is used on every experiment
camera = Camera('CameraRGB')
camera.set(FOV=90)
camera.set_image_size(800, 600)
camera.set_position(1.44, 0.0, 1.2)
camera.set_rotation(0, 0, 0)
# Based on the parameters, creates a vector with experiment objects.
experiments_vector = []
for weather in self.weathers:
for iteration in range(len(poses_tasks)):
poses = poses_tasks[iteration]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather
)
# Add all the cameras that were set for this experiments
conditions.add_sensor(camera)
experiment = Experiment()
experiment.set(
Conditions=conditions,
Poses=poses,
Task=iteration,
Repetitions=1
)
experiments_vector.append(experiment)
return experiments_vector
