def main():
"""Creates and runs the dataflow graph."""
def add(msg):
"""Mapping Function passed into MapOp,
returns a new Message that sums the data of each message in
msg.data."""
total = 0
for i in msg.data:
total += i.data
return erdos.Message(msg.timestamp, total)
(source_stream, ) = erdos.connect(SendOp,
erdos.OperatorConfig(name="SendOp"), [],
frequency=3)
(window_stream, ) = erdos.connect(window.TumblingWindow,
erdos.OperatorConfig(), [source_stream],
window_size=3)
(map_stream, ) = erdos.connect(map.Map,
erdos.OperatorConfig(), [window_stream],
function=add)
extract_stream = erdos.ExtractStream(map_stream)
erdos.run_async()
while True:
recv_msg = extract_stream.read()
print("ExtractStream: received {recv_msg}".format(recv_msg=recv_msg))
def main():
"""Creates and runs the dataflow graph."""
(count_stream, ) = erdos.connect(SendOp, erdos.OperatorConfig(), [])
erdos.connect(CallbackOp, erdos.OperatorConfig(), [count_stream])
erdos.connect(PullOp, erdos.OperatorConfig(), [count_stream])
erdos.connect(TryPullOp, erdos.OperatorConfig(), [count_stream])
erdos.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--payload', default=8, type=int)
parser.add_argument('-s', '--scenario', default="dataflow")
parser.add_argument('-n', '--name', default="test")
parser.add_argument('-t', '--transport', default="tcp")
parser.add_argument('-g', '--graph-file')
parser.add_argument('-o', '--operators', action='store_true')
args = parser.parse_args()
# creating Zenoh.net session
#session = zenoh.net.open({})
"""Creates and runs the dataflow graph."""
if args.operators:
(count_stream, ) = erdos.connect(ZenohRecvOp,
erdos.OperatorConfig(), [],
size=args.payload)
erdos.connect(CallbackOp,
erdos.OperatorConfig(), [count_stream],
size=args.payload,
scenario=args.scenario,
name=args.name,
transport=args.transport)
if args.graph_file is not None:
erdos.run(args.graph_file)
else:
erdos.run()
else:
#creating Zenoh.net session
session = zenoh.net.open({})
ingest_stream = erdos.IngestStream()
erdos.connect(CallbackOp,
erdos.OperatorConfig(), [ingest_stream],
size=args.payload,
scenario=args.scenario,
name=args.name,
transport=args.transport)
if args.graph_file is not None:
erdos.run_async(args.graph_file)
else:
erdos.run_async()
def listener(sample):
msg = pickle.loads(sample.payload)
ingest_stream.send(msg)
# Creating subscriber info
sub_info = SubInfo(Reliability.Reliable, SubMode.Push)
# declaring subscriber
sub = session.declare_subscriber(f'/thr/test/{args.payload}', sub_info,
listener)
while True:
time.sleep(60)
def main():
"""Creates and runs the dataflow graph."""
(count_stream, ) = erdos.connect(SendOp, erdos.OperatorConfig(), [])
(top_stream, ) = erdos.connect(TopOp, erdos.OperatorConfig(), [])
(batch_stream, ) = erdos.connect(BatchOp, erdos.OperatorConfig(),
[count_stream])
erdos.connect(CallbackWatermarkListener, erdos.OperatorConfig(),
[batch_stream, top_stream])
erdos.connect(PullWatermarkListener, erdos.OperatorConfig(),
[batch_stream])
erdos.run()
def main():
"""Creates and runs the dataflow graph."""
(left_stream, ) = erdos.connect(SendOp,
erdos.OperatorConfig(name="FastSendOp"),
[],
frequency=2)
(right_stream, ) = erdos.connect(SendOp,
erdos.OperatorConfig(name="SlowSendOp"),
[],
frequency=1)
erdos.connect(JoinOp, erdos.OperatorConfig(), [left_stream, right_stream])
erdos.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--payload', default=8, type=int)
parser.add_argument('-s', '--scenario', default="dataflow")
parser.add_argument('-n', '--name', default="test")
parser.add_argument('-t', '--transport', default="tcp")
parser.add_argument('-o', '--operators', action='store_true')
parser.add_argument('-g', '--graph-file')
args = parser.parse_args()
zenoh.init_logger()
# creating Zenoh.net session
#session = zenoh.net.open({})
"""Creates and runs the dataflow graph."""
(count_stream, ) = erdos.connect(SendOp,
erdos.OperatorConfig(), [],
size=args.payload)
if args.operators:
erdos.connect(ZenohSendOp,
erdos.OperatorConfig(), [count_stream],
size=args.payload)
if args.graph_file is not None:
erdos.run(args.graph_file)
else:
erdos.run()
else:
extract_stream = erdos.ExtractStream(count_stream)
# creating zenoh session
session = zenoh.net.open({})
# Declaring zenoh sender
rid = session.declare_resource(f'/thr/test/{args.payload}')
publisher = session.declare_publisher(rid)
if args.graph_file is not None:
erdos.run_async(args.graph_file)
else:
erdos.run_async()
counter = Counter(size=args.payload,
scenario=args.scenario,
name=args.name,
transport=args.transport)
while True:
msg = extract_stream.read()
counter.inc()
def main():
"""Creates and runs the dataflow graph."""
loop_stream = erdos.LoopStream()
(stream, ) = erdos.connect(LoopOp, erdos.OperatorConfig(), [loop_stream])
loop_stream.set(stream)
erdos.run()
def add_imu_visualizer(imu_stream, name='imu_visualizer_operator'):
from pylot.debug.imu_visualizer_operator import IMUVisualizerOperator
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(IMUVisualizerOperator, op_config, [imu_stream], FLAGS)
def add_drive_by_wire_operator(control_stream):
op_config = erdos.OperatorConfig(name='drive_by_wire_operator',
flow_watermarks=False,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(DriveByWireOperator, op_config, [control_stream], FLAGS)
def add_eval_metric_logging(collision_stream, lane_invasion_stream,
traffic_light_invasion_stream, imu_stream,
pose_stream, obstacle_stream):
""" Adds an evaluation metric logging operator to the pipeline.
Args:
collision_stream (:py:class:`erdos.ReadStream`): Stream on which the
collision events are received.
lane_invasion_stream (:py:class:`erdos.ReadStream`): Stream on which
the lane invasion events are received.
traffic_light_invasion_stream (:py:class:`erdos.ReadStream`): Stream on
which the traffic light invasion events are received.
imu_stream (:py:class:`erdos.ReadStream`): Stream on which the IMU
messages are received.
"""
from pylot.loggers.eval_metric_logger_operator import \
EvalMetricLoggerOperator
op_config = erdos.OperatorConfig(name='eval_metric_logger_operator',
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(EvalMetricLoggerOperator, op_config, [
collision_stream, lane_invasion_stream, traffic_light_invasion_stream,
imu_stream, pose_stream, obstacle_stream
], FLAGS)
def add_camera_visualizer(camera_stream, name):
from pylot.debug.camera_visualizer_operator import CameraVisualizerOperator
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(CameraVisualizerOperator, op_config, [camera_stream])
def add_imu_logging(imu_stream, name='imu_logger_operator'):
from pylot.loggers.imu_logger_operator import IMULoggerOperator
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(IMULoggerOperator, op_config, [imu_stream], FLAGS)
def add_camera_logging(stream, name, filename_prefix):
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(CameraLoggerOperator, op_config, [stream], FLAGS,
filename_prefix)
def add_prediction_visualizer(obstacle_tracking_stream,
prediction_stream,
vehicle_id_stream,
camera_transform,
release_sensor_stream,
name='top_down_tracking_visualizer_operator'):
from pylot.debug.track_visualizer_operator import TrackVisualizerOperator
top_down_transform = pylot.utils.get_top_down_transform(
camera_transform, FLAGS.top_down_lateral_view)
(top_down_segmented_camera_stream,
notify_reading_stream,
top_down_segmented_camera_setup) = \
pylot.operator_creator.add_segmented_camera(
top_down_transform,
vehicle_id_stream,
release_sensor_stream,
name='top_down_segmented_camera',
fov=90)
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(TrackVisualizerOperator, op_config, [
obstacle_tracking_stream, prediction_stream,
top_down_segmented_camera_stream
], FLAGS)
def add_obstacle_location_finder(obstacles_stream, depth_stream, pose_stream,
camera_setup):
"""Adds an operator that finds the world locations of the obstacles.
Args:
obstacles_stream (:py:class:`erdos.ReadStream`): Stream on which
detected obstacles are received.
depth_stream (:py:class:`erdos.ReadStream`): Stream on which
either point cloud messages or depth frames are received. The
message type differs dependening on how data-flow operators are
connected.
pose_stream (:py:class:`erdos.ReadStream`, optional): Stream on
which pose info is received.
camera_setup (:py:class:`~pylot.drivers.sensor_setup.CameraSetup`):
The setup of the center camera.
Returns:
:py:class:`erdos.ReadStream`: Stream on which
:py:class:`~pylot.perception.messages.ObstaclesMessage` messages with
world locations are published.
"""
from pylot.perception.detection.obstacle_location_finder_operator import \
ObstacleLocationFinderOperator
op_config = erdos.OperatorConfig(name=camera_setup.get_name() +
'_location_finder_operator',
flow_watermarks=False,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
[obstacles_with_loc_stream
] = erdos.connect(ObstacleLocationFinderOperator, op_config,
[obstacles_stream, depth_stream, pose_stream], FLAGS,
camera_setup)
return obstacles_with_loc_stream
def add_obstacle_location_history(obstacles_stream, depth_stream, pose_stream,
camera_stream, camera_setup):
"""Adds an operator that finds obstacle trajectories in world coordinates.
Args:
obstacles_stream (:py:class:`erdos.ReadStream`): Stream on which
detected obstacles are received.
depth_stream (:py:class:`erdos.ReadStream`): Stream on which
either point cloud messages or depth frames are received. The
message type differs dependening on how data-flow operators are
connected.
pose_stream (:py:class:`erdos.ReadStream`, optional): Stream on
which pose info is received.
camera_stream (:py:class:`erdos.ReadStream`): The stream on which
camera frames are received.
camera_setup (:py:class:`~pylot.drivers.sensor_setup.CameraSetup`):
The setup of the center camera.
Returns:
:py:class:`erdos.ReadStream`: Stream on which
:py:class:`~pylot.perception.messages.ObstacleTrajectoriesMessage`
messages are published.
"""
from pylot.perception.tracking.obstacle_location_history_operator import \
ObstacleLocationHistoryOperator
op_config = erdos.OperatorConfig(name=camera_setup.get_name() +
'_location_finder_history_operator',
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
[tracked_obstacles] = erdos.connect(
ObstacleLocationHistoryOperator, op_config,
[obstacles_stream, depth_stream, pose_stream, camera_stream], FLAGS,
camera_setup)
return tracked_obstacles
def add_pose_visualizer(pose_stream, name='pose_visualizer_operator'):
from pylot.debug.pose_visualizer_operator import PoseVisualizerOperator
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(PoseVisualizerOperator, op_config, [pose_stream], FLAGS)
def add_carla_bridge(control_stream):
from pylot.simulation.carla_operator import CarlaOperator
op_config = erdos.OperatorConfig(name='carla_operator',
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
return erdos.connect(CarlaOperator, op_config, [control_stream], FLAGS)
def add_localization():
op_config = erdos.OperatorConfig(name='ndt_localizer_operator',
flow_watermarks=False,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
[pose_stream] = erdos.connect(NDTAutowareOperator, op_config, [], FLAGS)
return pose_stream
def add_lidar_visualizer(point_cloud_stream, name='lidar_visualizer_operator'):
from pylot.debug.lidar_visualizer_operator import LidarVisualizerOperator
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(LidarVisualizerOperator, op_config, [point_cloud_stream],
FLAGS)
def add_detection_decay(ground_obstacles_stream):
op_config = erdos.OperatorConfig(name='detection_decay_operator',
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
[map_stream] = erdos.connect(DetectionDecayOperator, op_config,
[ground_obstacles_stream], FLAGS)
return map_stream
def add_segmentation(bgr_camera_stream, name='drn_segmentation_operator'):
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
[segmented_stream] = erdos.connect(SegmentationDRNOperator, op_config,
[bgr_camera_stream], FLAGS)
return segmented_stream
def add_linear_prediction(tracking_stream):
op_config = erdos.OperatorConfig(name='linear_prediction_operator',
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
[prediction_stream] = erdos.connect(LinearPredictorOperator, op_config,
[tracking_stream], FLAGS)
return prediction_stream
def add_trajectory_logging(obstacles_tracking_stream,
name='trajectory_logger_operator'):
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(TrajectoryLoggerOperator, op_config,
[obstacles_tracking_stream], FLAGS)
def add_multiple_object_tracker_logging(
obstacles_stream, name='multiple_object_tracker_logger_operator'):
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(MultipleObjectTrackerLoggerOperator, op_config,
[obstacles_stream], FLAGS)
def add_bounding_box_logging(obstacles_stream,
name='bounding_box_logger_operator'):
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(BoundingBoxLoggerOperator, op_config, [obstacles_stream],
FLAGS)
def add_pid_control(pose_stream, waypoints_stream):
from pylot.control.pid_control_operator import PIDControlOperator
op_config = erdos.OperatorConfig(name='pid_control_operator',
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
[control_stream] = erdos.connect(PIDControlOperator, op_config,
[pose_stream, waypoints_stream], FLAGS)
return control_stream
def add_mpc(pose_stream, waypoints_stream):
from pylot.control.mpc.mpc_operator import MPCOperator
op_config = erdos.OperatorConfig(name='mpc_operator',
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
[control_stream] = erdos.connect(MPCOperator, op_config,
[pose_stream, waypoints_stream], FLAGS)
return control_stream
def add_lidar_logging(point_cloud_stream,
name='lidar_logger_operator',
filename_prefix='carla-lidar-'):
op_config = erdos.OperatorConfig(name=name,
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
erdos.connect(LidarLoggerOperator, op_config, [point_cloud_stream], FLAGS,
filename_prefix)
def add_time_to_decision(pose_stream, obstacles_stream):
from pylot.control.time_to_decision_operator import TimeToDecisionOperator
op_config = erdos.OperatorConfig(name='time_to_decision_operator',
log_file_name=FLAGS.log_file_name,
csv_log_file_name=FLAGS.csv_log_file_name,
profile_file_name=FLAGS.profile_file_name)
[time_to_decision] = erdos.connect(TimeToDecisionOperator, op_config,
[pose_stream, obstacles_stream], FLAGS)
return time_to_decision
