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' }) ]