def make_carla_settings(args):
"""Make a CarlaSettings object with the settings we need.
"""
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=65,
NumberOfPedestrians=10,
WeatherId=1)
#settings.randomize_seeds()#uncomment to get different random settings
#initialize depth and rgb camera
camera1 = Camera('CameraDepth', PostProcessing='Depth', FOV=fov)
camera1.set_image_size(*image_size)
camera1.set_position(*camera_local_pos)
camera1.set_rotation(*camera_local_rotation)
settings.add_sensor(camera1)
camera2 = Camera('CameraRGB', PostProcessing='SceneFinal', FOV=fov)
camera2.set_image_size(*image_size)
camera2.set_position(*camera_local_pos)
camera2.set_rotation(*camera_local_rotation)
settings.add_sensor(camera2)
return settings, camera2
def start_new_episode(self, player_index):
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=random.choice([1, 3, 7, 8, 14]))
settings.randomize_seeds()
camera0 = Camera('CameraRGB')
camera0.set(CameraFOV=100)
camera0.set_image_size(800, 400)
camera0.set_position(120, 0, 130)
settings.add_sensor(camera0)
camera2 = Camera('CameraSeg', PostProcessing='SemanticSegmentation')
camera2.set(CameraFOV=100)
camera2.set_image_size(800, 400)
camera2.set_position(120, 0, 130)
settings.add_sensor(camera2)
self.client.load_settings(settings)
self.episode_index += 1
self.frame = 0
print('\nStarting episode {0}.'.format(self.episode_index))
self.client.start_episode(player_index)
def client_init(self, client):
self.client = client
self.carla_settings = CarlaSettings()
self.carla_settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
QualityLevel='Low',
)
camera0 = Camera('CameraRGB')
camera0.set_image_size(self.HEIGHT, self.WIDTH)
camera0.set_position(2.0, 0.0, 1.4)
camera0.set_rotation(0.0, 0.0, 0.0)
camera1 = Camera('CameraSegmentation', PostProcessing='SemanticSegmentation')
camera1.set_image_size(self.HEIGHT, self.WIDTH)
camera1.set_position(2.0, 0, 1.4)
self.settings = CarlaSettings()
self.settings.add_sensor(camera0)
self.settings.add_sensor(camera1)
scene = self.client.load_settings(self.settings)
start_spots = scene.player_start_spots
self.target = start_spots[26]
self.player_start = 26
cv2.namedWindow('im', cv2.WINDOW_NORMAL)
def generate_settings_scenario_010():
logging.info('Scenario 010: 3 cameras')
settings = make_base_settings()
settings.add_sensor(Camera('DefaultRGBCamera'))
settings.add_sensor(Camera('DefaultDepthCamera', PostProcessing='Depth'))
settings.add_sensor(Camera('DefaultSemSegCamera', PostProcessing='SemanticSegmentation'))
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
# 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,
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(0.1, 0, 1.7)
settings.add_sensor(camera1)
camera2 = Camera("CameraRGB")
camera2.set_image_size(self.config["render_x_res"],
self.config["render_y_res"])
camera2.set_position(0.1, 0, 1.7)
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"])
image, py_measurements = self._read_observation()
self.prev_measurement = py_measurements
return self.encode_obs(self.preprocess_image(image), py_measurements)
def run(self):
settings = CarlaSettings(QualityLevel='Low')
settings.add_sensor(Lidar('DefaultLidar'))
settings.add_sensor(Camera('DefaultCamera'))
settings.add_sensor(Camera('DefaultDepth', PostProcessing='Depth'))
settings.add_sensor(
Camera('DefaultSemSeg', PostProcessing='SemanticSegmentation'))
self.run_carla_client(settings, 3, 200)
def run(self):
settings = CarlaSettings()
settings.add_sensor(Camera('DefaultCamera'))
camera2 = Camera('Camera2')
camera2.set(PostProcessing='Depth', CameraFOV=120)
camera2.set_image_size(1924, 1028)
settings.add_sensor(camera2)
self.run_carla_client(settings, 3, 100)
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.prev_measurement = 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.weather = random.choice(self.config["weather"])
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=self.config["num_vehicles"],
NumberOfPedestrians=self.config["num_pedestrians"],
WeatherId=self.weather)
settings.randomize_seeds()
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)
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)
settings.add_sensor(camera2)
scene = self.client.load_settings(settings)
# Choose one player start at random.
number_of_player_starts = len(scene.player_start_spots)
if self.config["random_starting_location"]:
self.player_start = random.randint(
0, max(0, number_of_player_starts - 1))
else:
self.player_start = 0
# Notify the server that we want to start the episode at the
# player_start index. This function blocks until the server is ready
# to start the episode.
print("Starting new episode...")
self.client.start_episode(self.player_start)
image, py_measurements = self._read_observation()
self.prev_measurement = py_measurements
return self.preprocess_image(image)
def generate_settings_scenario_005():
logging.info(
'Scenario 005: single camera SemanticSegmentation, no agents info')
settings = make_base_settings()
settings.add_sensor(
Camera('DefaultCamera', PostProcessing='SemanticSegmentation'))
return settings
def _setup_carla_client(self):
carla_client = CarlaClient(self._params['host'], self._params['port'], timeout=None)
carla_client.connect()
### create initial settings
carla_settings = CarlaSettings()
carla_settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=self._params['number_of_vehicles'],
NumberOfPedestrians=self._params['number_of_pedestrians'],
WeatherId=self._params['weather'])
carla_settings.randomize_seeds()
### add cameras
for camera_name in self._params['cameras']:
camera_params = self._params[camera_name]
camera_postprocessing = camera_params['postprocessing']
camera = Camera(camera_name, PostProcessing=camera_postprocessing)
camera.set_image_size(CarlaCollSpeedEnv.CAMERA_HEIGHT * CarlaCollSpeedEnv.WIDTH_TO_HEIGHT_RATIO, CarlaCollSpeedEnv.CAMERA_HEIGHT)
camera.set_position(*camera_params['position'])
camera.set(**{'FOV': camera_params['fov']})
carla_settings.add_sensor(camera)
### load settings
carla_scene = carla_client.load_settings(carla_settings)
self._carla_client = carla_client
self._carla_settings = carla_settings
self._carla_scene = carla_scene
def __add_camera(self,
name,
postprocessing,
image_size=(800, 600),
field_of_view=90.0,
position=(0.3, 0, 1.3),
rotation_pitch=0,
rotation_roll=0,
rotation_yaw=0):
"""Adds a camera and a corresponding output stream.
Args:
name: A string naming the camera.
postprocessing: "SceneFinal", "Depth", "SemanticSegmentation".
"""
camera = Camera(name,
PostProcessing=postprocessing,
FOV=field_of_view,
ImageSizeX=image_size[0],
ImageSizeY=image_size[1],
PositionX=position[0],
PositionY=position[1],
PositionZ=position[2],
RotationPitch=rotation_pitch,
RotationRoll=rotation_roll,
RotationYaw=rotation_yaw)
self.settings.add_sensor(camera)
def __add_camera(self, camera_setup):
"""Adds a camera and a corresponding output stream.
Args:
camera_setup: A camera setup object.
"""
# Transform from Carla 0.9.x postprocessing strings to Carla 0.8.4.
if camera_setup.camera_type == 'sensor.camera.rgb':
postprocessing = 'SceneFinal'
elif camera_setup.camera_type == 'sensor.camera.depth':
postprocessing = 'Depth'
elif camera_setup.camera_type == 'sensor.camera.semantic_segmentation':
postprocessing = 'SemanticSegmentation'
transform = camera_setup.get_transform()
camera = Camera(name=camera_setup.name,
PostProcessing=postprocessing,
FOV=camera_setup.fov,
ImageSizeX=camera_setup.width,
ImageSizeY=camera_setup.height,
PositionX=transform.location.x,
PositionY=transform.location.y,
PositionZ=transform.location.z,
RotationPitch=transform.rotation.pitch,
RotationRoll=transform.rotation.roll,
RotationYaw=transform.rotation.yaw)
self._settings.add_sensor(camera)
def __setup_camera_tranforms(self,
name,
postprocessing,
field_of_view=90.0,
image_size=(800, 600),
position=(0.3, 0, 1.3),
rotation_pitch=0,
rotation_roll=0,
rotation_yaw=0):
camera = Camera(name,
PostProcessing=postprocessing,
FOV=field_of_view,
ImageSizeX=image_size[0],
ImageSizeY=image_size[1],
PositionX=position[0],
PositionY=position[1],
PositionZ=position[2],
RotationPitch=rotation_pitch,
RotationRoll=rotation_roll,
RotationYaw=rotation_yaw)
image_width = image_size[0]
image_height = image_size[1]
# (Intrinsic) K Matrix
intrinsic_mat = np.identity(3)
intrinsic_mat[0][2] = image_width / 2
intrinsic_mat[1][2] = image_height / 2
intrinsic_mat[0][0] = intrinsic_mat[1][1] = image_width / (
2.0 * math.tan(90.0 * math.pi / 360.0))
return (intrinsic_mat, camera.get_unreal_transform(), (image_width,
image_height))
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(200, 88)
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]
#weather=14
#poses = [[54, 60]]
#poses=[[37,76]]
#poses = [[80, 29]]
#poses = [[50,43]]
vehicles = vehicles_tasks[iteration]
pedestrians = pedestrians_tasks[iteration]
conditions = CarlaSettings()
conditions.set(SendNonPlayerAgentsInfo=True,
NumberOfVehicles=vehicles,
NumberOfPedestrians=pedestrians,
WeatherId=weather)
conditions.set(SynchronousMode=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 carla_init(client):
"""
:param client:
:return:
"""
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel='Epic')
# CAMERA
camera0 = Camera('CameraRGB')
# Set image resolution in pixels.
camera0.set_image_size(800, 600)
# Set its position relative to the car in meters.
camera0.set_position(0.30, 0, 1.30)
settings.add_sensor(camera0)
# Let's add another camera producing ground-truth depth.
camera1 = Camera('CameraDepth', PostProcessing='Depth')
camera1.set_image_size(800, 600)
camera1.set_position(0.30, 0, 1.30)
settings.add_sensor(camera1)
# 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)
scene = client.load_settings(settings)
# define the starting point of the agent
player_start = 140
client.start_episode(player_start)
print('Starting new episode at %r, %d...' % (scene.map_name, player_start))
def get_default_carla_settings(args):
settings = CarlaSettings(SynchronousMode=args.synchronous,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=1)
settings.add_sensor(Camera('Camera1'))
return str(settings)
def _build_camera(self, name, post):
camera = Camera(name, PostProcessing=post)
camera.set_image_size(
self.config["render_x_res"], self.config["render_y_res"])
camera.set_position(x=2.4, y=0, z=0.8)
camera.set_rotation(pitch=-40, roll=0, yaw=0)
# camera.FOV = 100
return camera
def create_camera(self, camera_name, PostProcessing):
#camera = Camera('CameraRGB')
#camera.set_image_size(carla_config.server_width, carla_config.server_height)
#camera.set_position(200, 0, 140)
#camera.set_rotation(0, 0, 0)
#self.settings.add_sensor(camera)
camera = Camera(camera_name, **dict(self.camera_settings, PostProcessing=PostProcessing))
return camera
def run(self):
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=60,
NumberOfPedestrians=90)
settings.add_sensor(Camera('DefaultCamera'))
self.run_carla_client(settings, 3, 100)
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 _add_sensors(self):
camera0 = Camera('RenderCamera0')
# Set image resolution in pixels.
camera0.set_image_size(800, 600)
# Set its position relative to the car in meters.
camera0.set_position(-4.30, 0, 2.60)
camera0.set_rotation(pitch=-25, yaw=0, roll=0)
self.settings.add_sensor(camera0)
def _add_cameras(self, settings, cameras, camera_width, camera_height):
# add a front facing camera
if CameraTypes.FRONT in cameras:
camera = Camera(CameraTypes.FRONT.value)
camera.set_image_size(camera_width, camera_height)
camera.set_position(0.2, 0, 1.3)
camera.set_rotation(8, 0, 0)
settings.add_sensor(camera)
# add a left facing camera
if CameraTypes.LEFT in cameras:
camera = Camera(CameraTypes.LEFT.value)
camera.set_image_size(camera_width, camera_height)
camera.set_position(0.2, 0, 1.3)
camera.set_rotation(8, -30, 0)
settings.add_sensor(camera)
# add a right facing camera
if CameraTypes.RIGHT in cameras:
camera = Camera(CameraTypes.RIGHT.value)
camera.set_image_size(camera_width, camera_height)
camera.set_position(0.2, 0, 1.3)
camera.set_rotation(8, 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)
return settings
def reset(self):
"""
:return:
"""
settings = CarlaSettings()
settings.set(SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=20,
NumberOfPedestrians=40,
WeatherId=random.choice([1, 3, 7, 8, 14]),
QualityLevel='Epic')
# CAMERA
camera0 = Camera('CameraRGB', PostProcessing='SceneFinal')
# Set image resolution in pixels.
camera0.set_image_size(800, 600)
# Set its position relative to the car in meters.
camera0.set_position(0.30, 0, 1.30)
settings.add_sensor(camera0)
# Let's add another camera producing ground-truth depth.
# camera1 = Camera('CameraDepth', PostProcessing='Depth')
# camera1.set_image_size(800, 600)
# camera1.set_position(0.30, 0, 1.30)
# settings.add_sensor(camera1)
# 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)
scene = self.carla_client.load_settings(settings)
self.pre_image = None
self.cur_image = None
self.pre_measurements = None
self.cur_measurements = None
# define a random starting point of the agent for the appropriate trainning
number_of_player_starts = len(scene.player_start_spots)
player_start = random.randint(0, max(0, number_of_player_starts - 1))
# player_start = 140
self.carla_client.start_episode(player_start)
print('Starting new episode at %r, %d...' %
(scene.map_name, player_start))
# TODO: read and return status after reset
return
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 __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, 15, 70]
pedestrians_tasks = [0, 50, 150]
task_names = ['empty', 'normal', 'cluttered']
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 default_settings():
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=True,
NumberOfVehicles=0,
NumberOfPedestrians=0,
WeatherId=1, # random.choice([1, 3, 7, 8, 14]),
PlayerVehicle='/Game/Blueprints/Vehicles/Mustang/Mustang.Mustang_C',
QualityLevel='Epic')
settings.randomize_seeds()
camera_RGB = Camera('CameraRGB')
camera_RGB.set_image_size(256, 256)
camera_RGB.set_position(1, 0, 2.50)
settings.add_sensor(camera_RGB)
camera_seg = Camera('CameraSegmentation',
PostProcessing='SemanticSegmentation')
camera_seg.set_image_size(256, 256)
camera_seg.set_position(1, 0, 2.50)
settings.add_sensor(camera_seg)
return settings
def gen_settings(args):
settings = CarlaSettings()
settings.set(
SynchronousMode=True,
SendNonPlayerAgentsInfo=False,
NumberOfVehicles=0,
NumberOfPedestrians=0,
WeatherId=args.weather,
QualityLevel=args.quality_level)
settings.randomize_seeds()
camera_pos_x = 2
camera_pos_y = 0
camera_pos_z = 1
camera = Camera("MainCamera")
camera.set_image_size(800, 600)
camera.set_position(camera_pos_x, camera_pos_y, camera_pos_z)
settings.add_sensor(camera)
return settings
