def process_imu(self, imu_msg):
"""Invoked when an IMU message is received from the simulator.
Sends IMU measurements to downstream operators.
Args:
imu_msg (carla.IMUMeasurement): IMU reading.
"""
game_time = int(imu_msg.timestamp * 1000)
timestamp = erdos.Timestamp(coordinates=[game_time])
watermark_msg = erdos.WatermarkMessage(timestamp)
with erdos.profile(self.config.name + '.process_imu',
self,
event_data={'timestamp': str(timestamp)}):
with self._lock:
msg = IMUMessage(
timestamp,
Transform.from_carla_transform(imu_msg.transform),
Vector3D.from_carla_vector(imu_msg.accelerometer),
Vector3D.from_carla_vector(imu_msg.gyroscope),
imu_msg.compass)
self._imu_stream.send(msg)
# Note: The operator is set not to automatically propagate
# watermark messages received on input streams. Thus, we can
# issue watermarks only after the Carla callback is invoked.
self._imu_stream.send(watermark_msg)
def process_point_clouds(self, simulator_pc):
""" Invoked when a point cloud is received from the simulator.
"""
game_time = int(simulator_pc.timestamp * 1000)
timestamp = erdos.Timestamp(coordinates=[game_time])
watermark_msg = erdos.WatermarkMessage(timestamp)
with erdos.profile(self.config.name + '.process_point_clouds',
self,
event_data={'timestamp': str(timestamp)}):
# Ensure that the code executes serially
with self._lock:
assert len(
simulator_pc.raw_data) > 0, 'Lidar did not send any points'
# Include the transform relative to the vehicle.
# simulator_pc.transform returns the world transform, but
# we do not use it directly.
msg = PointCloudMessage(
timestamp,
PointCloud.from_simulator_point_cloud(
simulator_pc, self._lidar_setup))
if self._release_data:
self._lidar_stream.send(msg)
self._lidar_stream.send(watermark_msg)
else:
# Pickle the data, and release it upon release msg receipt.
pickled_msg = pickle.dumps(
msg, protocol=pickle.HIGHEST_PROTOCOL)
with self._pickle_lock:
self._pickled_messages[msg.timestamp] = pickled_msg
self._notify_reading_stream.send(watermark_msg)
def process_images(self, simulator_image):
""" Invoked when an image is received from the simulator.
Args:
simulator_image: a carla.Image.
"""
game_time = int(simulator_image.timestamp * 1000)
timestamp = erdos.Timestamp(coordinates=[game_time])
watermark_msg = erdos.WatermarkMessage(timestamp)
with erdos.profile(self.config.name + '.process_images',
self,
event_data={'timestamp': str(timestamp)}):
# Ensure that the code executes serially
with self._lock:
msg = None
if self._camera_setup.camera_type == 'sensor.camera.rgb':
msg = FrameMessage(
timestamp,
CameraFrame.from_simulator_frame(
simulator_image, self._camera_setup))
elif self._camera_setup.camera_type == 'sensor.camera.depth':
# Include the transform relative to the vehicle.
# simulator_image.transform returns the world transform,
# but we do not use it directly.
msg = DepthFrameMessage(
timestamp,
DepthFrame.from_simulator_frame(
simulator_image,
self._camera_setup,
save_original_frame=self._flags.
visualize_depth_camera))
elif (self._camera_setup.camera_type ==
'sensor.camera.semantic_segmentation'):
msg = SegmentedFrameMessage(
timestamp,
SegmentedFrame.from_simulator_image(
simulator_image, self._camera_setup))
if self._release_data:
self._camera_stream.send(msg)
self._camera_stream.send(watermark_msg)
else:
# Pickle the data, and release it upon release msg receipt.
pickled_msg = pickle.dumps(
msg, protocol=pickle.HIGHEST_PROTOCOL)
with self._pickle_lock:
self._pickled_messages[msg.timestamp] = pickled_msg
self._notify_reading_stream.send(watermark_msg)
def process_gnss(self, gnss_msg):
"""Invoked when a GNSS measurement is received from the simulator.
Sends GNSS measurements to downstream operators.
"""
game_time = int(gnss_msg.timestamp * 1000)
timestamp = erdos.Timestamp(coordinates=[game_time])
watermark_msg = erdos.WatermarkMessage(timestamp)
with erdos.profile(self.config.name + '.process_gnss',
self,
event_data={'timestamp': str(timestamp)}):
with self._lock:
msg = GNSSMessage(
timestamp,
Transform.from_simulator_transform(gnss_msg.transform),
gnss_msg.altitude, gnss_msg.latitude, gnss_msg.longitude)
self._gnss_stream.send(msg)
self._gnss_stream.send(watermark_msg)
def send_actor_data(self, msg):
""" Callback function that gets called when the world is ticked.
This function sends a WatermarkMessage to the downstream operators as
a signal that they need to release data to the rest of the pipeline.
Args:
msg: Data recieved from the simulation at a tick.
"""
game_time = int(msg.elapsed_seconds * 1000)
self._logger.info('The world is at the timestamp {}'.format(game_time))
timestamp = erdos.Timestamp(coordinates=[game_time])
watermark_msg = erdos.WatermarkMessage(timestamp)
with erdos.profile(self.config.name + '.send_actor_data',
self,
event_data={'timestamp': str(timestamp)}):
localization_update, control_update = False, False
if (self._flags.carla_localization_frequency == -1
or self._next_localization_sensor_reading is None
or game_time == self._next_localization_sensor_reading):
if self._flags.carla_mode == 'pseudo-asynchronous':
self._update_next_localization_pseudo_asynchronous_ticks(
game_time)
self.__send_hero_vehicle_data(self.pose_stream, timestamp,
watermark_msg)
self.__send_ground_actors_data(timestamp, watermark_msg)
self.__update_spectactor_pose()
localization_update = True
if self._flags.carla_mode == "pseudo-asynchronous" and (
self._flags.carla_control_frequency == -1
or self._next_control_sensor_reading is None
or game_time == self._next_control_sensor_reading):
self._update_next_control_pseudo_asynchronous_ticks(game_time)
self.__send_hero_vehicle_data(self.pose_stream_for_control,
timestamp, watermark_msg)
self.__update_spectactor_pose()
control_update = True
# If we sent a localization message, but did not have a message
# through control for this time, then we need to tick the simulator
# forward. (only if we are in the pseudo-asynchronous mode)
if self._flags.carla_mode == "pseudo-asynchronous" and (
localization_update and not control_update):
self._consume_next_event()
def send_actor_data(self, msg):
""" Callback function that gets called when the world is ticked.
This function sends a WatermarkMessage to the downstream operators as
a signal that they need to release data to the rest of the pipeline.
Args:
msg: Data recieved from the simulation at a tick.
"""
# Ensure that the callback executes serially.
with self._lock:
game_time = int(msg.elapsed_seconds * 1000)
self._logger.info(
'The world is at the timestamp {}'.format(game_time))
timestamp = erdos.Timestamp(coordinates=[game_time])
watermark_msg = erdos.WatermarkMessage(timestamp)
with erdos.profile(self.config.name + '.send_actor_data',
self,
event_data={'timestamp': str(timestamp)}):
if (self._flags.carla_localization_frequency == -1
or self._next_localization_sensor_reading is None or
game_time == self._next_localization_sensor_reading):
if self._flags.carla_mode == 'pseudo-asynchronous':
self._update_next_localization_pseudo_async_ticks(
game_time)
self.__send_hero_vehicle_data(self.pose_stream, timestamp,
watermark_msg)
self.__send_ground_actors_data(timestamp, watermark_msg)
self.__update_spectactor_pose()
if self._flags.carla_mode == "pseudo-asynchronous" and (
self._flags.carla_control_frequency == -1
or self._next_control_sensor_reading is None
or game_time == self._next_control_sensor_reading):
self._update_next_control_pseudo_asynchronous_ticks(
game_time)
self.__send_hero_vehicle_data(self.pose_stream_for_control,
timestamp, watermark_msg)
self.__update_spectactor_pose()
