def setup_streams(input_streams, output_stream_name, ack_stream_name):
input_streams.filter(is_not_control_stream).add_callback(FluxConsumerOperator.on_msg)
input_streams.filter(is_control_stream).add_callback(FluxConsumerOperator.on_control_msg)
return [DataStream(name=output_stream_name,
labels={'back_pressure': 'true'}),
DataStream(name=ack_stream_name,
labels={'ack_stream': 'true'})]
def setup_streams(input_streams,
output_stream_name1,
output_stream_name2,
filter_stream_lambda=None):
input_streams.filter(filter_stream_lambda).add_callback(UnzipOp.on_msg)
return [
DataStream(name=output_stream_name1),
DataStream(name=output_stream_name2)
]
def setup_streams(input_streams):
# Add output streams for gym environment
return [
DataStream(data_type=float, name="race_reward_output"),
DataStream(data_type=np.ndarray,
name="race_state_output",
labels={'state': 'true'}),
DataStream(data_type=bool, name="race_done_output"),
DataStream(data_type=dict, name="race_info_output")
]
def __init__(self, action_name, action_type, command_stream, results_type,
feedback_type):
self.client = actionlib.SimpleActionClient(action_name, action_type)
self.client.wait_for_server()
self.result_stream = DataStream(data_type=results_type,
name=action_name + '-results')
self.feedback_stream = DataStream(data_type=feedback_type,
name=action_name + '-feedback')
self.command_stream = command_stream
# TODO(ionel): Figure out stream register so that on_next_command gets invoked.
self.command_stream.register(on_next_command)
def setup_streams(input_streams):
# Filter func
def is_lidar_stream(stream):
return stream.labels.get('lidar', '') == 'true'
def is_radar_stream(stream):
return stream.labels.get('radar', '') == 'true'
def is_gps_stream(stream):
return stream.labels.get('GPS', '') == 'true'
def is_imu_stream(stream):
return stream.labels.get('IMU', '') == 'true'
# Lidar stream
input_streams.filter(is_lidar_stream) \
.add_callback(SLAMOperator.on_point_cloud)
# Radar stream
input_streams.filter(is_radar_stream) \
.add_callback(SLAMOperator.on_radar)
# GPS stream
input_streams.filter(is_gps_stream) \
.add_callback(SLAMOperator.on_gps)
# IMU stream
input_streams.filter(is_imu_stream)\
.add_callback(SLAMOperator.on_imu)
# TODO(ionel): Specify output stream type
return [DataStream(name='location', labels={'positions': 'true'})]
def __add_lidar(self,
name,
channels=32,
max_range=50,
points_per_second=100000,
rotation_frequency=10,
upper_fov_limit=10,
lower_fov_limit=-30,
position=(0, 0, 1.4),
rotation_pitch=0,
rotation_yaw=0,
rotation_roll=0):
"""Adds a LIDAR sensor and a corresponding output stream.
Args:
name: A string naming the camera.
"""
lidar = Lidar(name,
Channels=channels,
Range=max_range,
PointsPerSecond=points_per_second,
RotationFrequency=rotation_frequency,
UpperFovLimit=upper_fov_limit,
LowerFovLimit=lower_fov_limit,
PositionX=position[0],
PositionY=position[1],
PositionZ=position[2],
RotationPitch=rotation_pitch,
RotationYaw=rotation_yaw,
RotationRoll=rotation_roll)
self.settings.add_sensor(lidar)
output_stream = DataStream(name=name, labels={"sensor_type": "lidar"})
self.lidar_streams.append(output_stream)
def setup_streams(input_streams):
def is_tracker_stream(stream):
return stream.labels.get('tracker', '') == 'true'
def is_positions_stream(stream):
return stream.labels.get('positions', '') == 'true'
def is_lidar_stream(stream):
return stream.labels.get('lidar', '') == 'true'
def is_radar_stream(stream):
return stream.labels.get('radar', '') == 'true'
def is_depth_camera_stream(stream):
return stream.labels.get('camera_type', '') == 'depth'
input_streams.filter(is_tracker_stream).add_callback(
FusionOperator.on_det_obj_msg)
input_streams.filter(is_positions_stream).add_callback(
FusionOperator.on_slam_msg)
input_streams.filter(is_lidar_stream).add_callback(
FusionOperator.on_lidar_msg)
input_streams.filter(is_radar_stream).add_callback(
FusionOperator.on_radar_msg)
input_streams.filter(is_depth_camera_stream).add_callback(
FusionOperator.on_depth_frame_msg)
# TODO(ionel): Set output type.
return [DataStream(name='fusion', labels={'fused': 'true'})]
def setup_streams(input_streams, trigger_stream_name, gripper_stream_name):
"""
Registers callbacks on the given streams and returns two streams, one
of which sends actions to the gripper and the other sends a message
upon completion of the action.
"""
input_streams.filter_name(trigger_stream_name)\
.add_callback(MockUngraspObjectOperator.grasp_object)
input_streams.filter_name(gripper_stream_name)\
.add_callback(MockUngraspObjectOperator.release_lock)
return [
DataStream(
data_type=MockGripType, name=MockUngraspObjectOperator.\
gripper_stream),
DataStream(data_type=Bool, name=MockUngraspObjectOperator.\
action_complete_stream_name)
]
def setup_streams(input_streams, input_stream_name, output_stream_name):
"""
Registers the callback for the given input stream and publishes an
output stream on the given name.
"""
input_streams.filter_name(input_stream_name).\
add_callback(GoToXYZOperator.move_joint_hook)
return [DataStream(data_type=Bool, name=output_stream_name)]
def setup_streams(input_streams, input_name, output_name):
"""
Filters the given stream from the input_streams and returns a single
output stream which sends images from the gel sight camera.
"""
input_streams.filter_name(input_name)\
.add_callback(GelSightOperator.on_msg_image_stream)
return [DataStream(data_type=Image, name=output_name)]
def setup_streams(input_streams, gripper_stream, output_stream_name):
"""
Registers callback on the given stream and publishes a completion
message on the given output stream name.
"""
input_streams.filter_name(gripper_stream).\
add_callback(MockGripperOperator.gripmove)
return [DataStream(data_type=Bool, name=output_stream_name)]
def setup_streams(input_streams, filename):
output_streams = []
with open(filename, "rb") as f:
stream_info = pickle.load(f)
for data_type, name in stream_info:
output_streams.append(
DataStream(data_type=data_type, name=name))
return output_streams
def setup_streams(input_streams):
input_streams.filter(checkpoint_util.is_control_stream) \
.add_callback(Sink.on_rollback_msg)
input_streams.filter(checkpoint_util.is_not_control_stream) \
.add_callback(Sink.on_msg)
return [
DataStream(name="sink_snapshot", labels={'no_watermark': 'true'})
]
def setup_streams(input_streams, trigger_stream_name,
goto_xyz_stream_name):
"""
Takes as input the stream that releases the lock upon successfull
completion of the given action and returns the output stream which
publishes the Pose to move the arm to.
"""
input_streams.filter_name(trigger_stream_name)\
.add_callback(MoveAboveObjectOperator.move_object)
input_streams.filter_name(goto_xyz_stream_name)\
.add_callback(MoveAboveObjectOperator.release_lock)
return [
DataStream(data_type=Pose,
name=MoveAboveObjectOperator.goto_stream_name),
DataStream(data_type=Bool,
name=MoveAboveObjectOperator.stream_name)
]
def setup_streams(input_streams, output_name):
def is_flush_stream(stream):
return stream.labels.get('flush', '') == 'true'
input_streams.filter(lambda stream: not is_flush_stream(stream)) \
.add_callback(BufferLogOp.on_log_msg)
input_streams.filter(is_flush_stream).add_callback(
BufferLogOp.on_flush_msg)
return [DataStream(name=output_name)]
def setup_streams(input_streams):
def is_positions_stream(stream):
return stream.labels.get('positions', '') == 'true'
input_streams.filter(is_positions_stream).add_callback(
MissionPlannerOperator.on_position_msg)
# TODO(ionel): Specify output type.
return [DataStream(name='directions', labels={'directions': 'true'})]
def setup_streams(input_streams, output_stream_name):
input_streams\
.filter(is_not_ack_stream)\
.filter(is_not_back_pressure)\
.add_callback(FluxProducerOperator.on_msg)
input_streams.filter(is_ack_stream).add_callback(
FluxProducerOperator.on_ack_msg)
return [DataStream(name=output_stream_name)]
def create_camera_stream(camera_setup, ground='true'):
labels = {
'sensor_type': 'camera',
'camera_type': camera_setup.camera_type,
'ground': ground
}
if camera_setup.camera_type == 'sensor.camera.semantic_segmentation':
labels['segmented'] = 'true'
return DataStream(name=camera_setup.name, labels=labels)
def setup_streams(input_streams, gel_sight_a_stream_name,
gel_sight_b_stream_name, trigger_stream_name):
"""
Registers a callback on the given gel sight streams and returns a
stream on which the prediction is sent.
"""
input_streams.filter_name(gel_sight_a_stream_name)\
.add_callback(MockPredictGripOperator.save_image_gelsight_a)
input_streams.filter_name(gel_sight_b_stream_name) \
.add_callback(MockPredictGripOperator.save_image_gelsight_b)
input_streams.filter_name(trigger_stream_name)\
.add_callback(MockPredictGripOperator.predict)
return [
DataStream(
data_type=Bool,
name=MockPredictGripOperator.success_stream_name),
DataStream(
data_type=Bool, name=MockPredictGripOperator.fail_stream_name)
]
def setup_streams(input_streams):
def is_bbox_stream(stream):
return stream.labels.get('type', '') == 'bbox'
input_streams.filter(is_bbox_stream).add_callback(
PredictionOperator.on_det_objs_msg)
return [
DataStream(name='prediction_stream', labels={'predictor': 'true'})
]
def __create_input_streams(self):
for name in self._camera_names:
stream = ROSOutputDataStream(
DataStream(name=name,
uid=name,
labels={
'sensor_type': 'camera',
'camera_type': 'sensor.camera.rgb',
'ground': 'true'
}))
self._camera_streams[name] = stream
self._can_bus_stream = ROSOutputDataStream(
DataStream(name='can_bus', uid='can_bus'))
# Stream on which we send the global trajectory.
self._global_trajectory_stream = ROSOutputDataStream(
DataStream(name='global_trajectory_stream',
uid='global_trajectory_stream',
labels={
'global': 'true',
'waypoints': 'true'
}))
input_streams = (
self._camera_streams.values() +
[self._global_trajectory_stream, self._can_bus_stream])
# if self.track == Track.ALL_SENSORS_HDMAP_WAYPOINTS:
# Stream on which we send the opendrive map.
self._open_drive_stream = ROSOutputDataStream(
DataStream(name='open_drive_stream', uid='open_drive_stream'))
input_streams.append(self._open_drive_stream)
if (self.track == Track.ALL_SENSORS
or self.track == Track.ALL_SENSORS_HDMAP_WAYPOINTS):
self._point_cloud_stream = ROSOutputDataStream(
DataStream(name='lidar',
uid='lidar',
labels={'sensor_type': 'sensor.lidar.ray_cast'}))
input_streams.append(self._point_cloud_stream)
return input_streams
def setup_streams(input_streams):
"""
Returns a single datastream which sends a boolean success value of the
insertion operation.
"""
return [
DataStream(
data_type=Bool,
name=InsertTableOperator.stream_name,
labels={"object": "table"})
]
def setup_streams(input_streams, locate_object_stream_name,
trigger_stream_name, goto_xyz_stream_name):
"""
Register callbacks to retrieve the destination locations and to wait
for completion of previously sent actions.
Return two streams. Send the Pose commands on the first and the
message completion command on the second.
"""
input_streams.filter_name(locate_object_stream_name) \
.add_callback(RandomPositionOperator.save_coords)
input_streams.filter_name(trigger_stream_name) \
.add_callback(RandomPositionOperator.generate_random_position)
input_streams.filter_name(goto_xyz_stream_name)\
.add_callback(RandomPositionOperator.release_lock)
return [
DataStream(data_type=Pose,
name=RandomPositionOperator.position_stream_name),
DataStream(data_type=Bool,
name=RandomPositionOperator.action_complete_stream_name)
]
def setup_streams(input_streams, op_name):
def is_rgb_camera_stream(stream):
return stream.labels.get('camera_type', '') == 'RGB'
input_streams.filter(is_rgb_camera_stream) \
.add_callback(SegmentationOperator.on_msg_camera_stream)
# TODO(ionel): Set output type.
return [
DataStream(name='{}_output'.format(op_name),
labels={'segmented': 'true'})
]
def setup_streams(input_streams, output_stream_name):
input_streams.filter(is_not_ack_stream)\
.filter(is_not_control_stream)\
.filter(is_not_back_pressure)\
.add_callback(FluxIngressOperator.on_msg) # Input
input_streams.filter(is_ack_stream).add_callback(
FluxIngressOperator.on_ack_msg) # Ack
input_streams.filter(is_control_stream).add_callback(
FluxIngressOperator.on_control_msg) # Control
return [DataStream(name=output_stream_name)]
def setup_streams(input_streams):
"""
Registers a callback on the given input streams and returns a single
stream which sends a Boolean value upon successful initialization.
"""
input_streams.add_callback(InitRobotOperator.init_robot_hook)
return [
DataStream(
data_type=Bool,
name=InitRobotOperator.stream_name,
labels={"object": "robot"})
]
def setup_streams(input_streams):
"""
Adds the insert_block_hook callback on all the received streams, and
returns a single stream which sends a boolean success value of the
insertion operation.
"""
input_streams.add_callback(InsertBlockOperator.insert_block_hook)
return [
DataStream(data_type=Bool,
name=InsertBlockOperator.stream_name,
labels={"object": "block"})
]
def setup_streams(input_streams,
output_stream_name,
camera_stream_name=None):
input_streams.filter(is_obstacles_stream).add_callback(
ObjectTrackerOp.on_objects_msg)
# Select camera input streams.
camera_streams = input_streams.filter(is_camera_stream)
if camera_stream_name:
# Select only the camera the operator is interested in.
camera_streams = camera_streams.filter_name(camera_stream_name)
# Register a callback on the camera input stream.
camera_streams.add_callback(ObjectTrackerOp.on_frame_msg)
return [DataStream(name=output_stream_name)]
def setup_streams(input_streams, location_stream_name,
trigger_stream_name):
"""
Registers a callback to retrieve the location where the arm needs to
be moved and returns a single output stream which sends the Pose
commands to move the robot to the required location.
"""
input_streams.filter_name(location_stream_name)\
.add_callback(RaiseObjectOperator.save_destination)
input_streams.filter_name(trigger_stream_name)\
.add_callback(RaiseObjectOperator.generate_move_commands)
return [
DataStream(data_type=Pose, name=RaiseObjectOperator.stream_name)
]
def setup_streams(input_streams, op_name):
def is_rgb_camera_stream(stream):
return stream.labels.get('camera_type', '') == 'RGB'
input_streams.filter(is_rgb_camera_stream) \
.add_callback(TrafficSignDetOperator.on_frame)
# TODO(ionel): Specify output stream type
return [
DataStream(name='{}_output'.format(op_name),
labels={
'signs': 'true',
'type': 'bbox'
})
]