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 create_data_flow(): """Creates a data-flow which process input data, and outputs commands. Returns: A tuple of streams. The first N - 1 streams are input streams on which the agent can send input data. The last stream is the control stream on which the agent receives control commands. """ pose_stream = erdos.IngestStream() open_drive_stream = erdos.IngestStream() global_trajectory_stream = erdos.IngestStream() # Currently, we do not use the scene layout information. # scene_layout_stream = erdos.IngestStream() ground_obstacles_stream = erdos.IngestStream() traffic_lights_stream = erdos.IngestStream() lanes_stream = erdos.IngestStream() time_to_decision_loop_stream = erdos.LoopStream() # Add waypoint planner. waypoints_stream = pylot.component_creator.add_planning( None, pose_stream, ground_obstacles_stream, traffic_lights_stream, lanes_stream, open_drive_stream, global_trajectory_stream, time_to_decision_loop_stream) control_stream = pylot.operator_creator.add_pid_control( pose_stream, waypoints_stream) extract_control_stream = erdos.ExtractStream(control_stream) time_to_decision_stream = pylot.operator_creator.add_time_to_decision( pose_stream, ground_obstacles_stream) time_to_decision_loop_stream.set(time_to_decision_stream) return (pose_stream, global_trajectory_stream, ground_obstacles_stream, traffic_lights_stream, lanes_stream, open_drive_stream, extract_control_stream)
def create_data_flow(): """ Create the challenge data-flow graph.""" track = get_track() time_to_decision_loop_stream = erdos.LoopStream() camera_setups = create_camera_setups(track) camera_streams = {} for name in camera_setups: camera_streams[name] = erdos.IngestStream() pose_stream = erdos.IngestStream() global_trajectory_stream = erdos.IngestStream() open_drive_stream = erdos.IngestStream() if (track == Track.ALL_SENSORS or track == Track.ALL_SENSORS_HDMAP_WAYPOINTS): point_cloud_stream = erdos.IngestStream() else: point_cloud_stream = pylot.operator_creator.add_depth_estimation( camera_streams[LEFT_CAMERA_NAME], camera_streams[RIGHT_CAMERA_NAME], camera_setups[CENTER_CAMERA_NAME]) obstacles_stream = pylot.operator_creator.add_obstacle_detection( camera_streams[CENTER_CAMERA_NAME], time_to_decision_loop_stream)[0] # Adds an operator that finds the world locations of the obstacles. obstacles_stream = pylot.operator_creator.add_obstacle_location_finder( obstacles_stream, point_cloud_stream, pose_stream, camera_streams[CENTER_CAMERA_NAME], camera_setups[CENTER_CAMERA_NAME]) traffic_lights_stream = pylot.operator_creator.add_traffic_light_detector( camera_streams[TL_CAMERA_NAME]) # Adds an operator that finds the world locations of the traffic lights. traffic_lights_stream = \ pylot.operator_creator.add_obstacle_location_finder( traffic_lights_stream, point_cloud_stream, pose_stream, camera_streams[TL_CAMERA_NAME], camera_setups[TL_CAMERA_NAME]) waypoints_stream = pylot.operator_creator.add_waypoint_planning( pose_stream, open_drive_stream, global_trajectory_stream, obstacles_stream, traffic_lights_stream, None) if FLAGS.visualize_rgb_camera: pylot.operator_creator.add_camera_visualizer( camera_streams[CENTER_CAMERA_NAME], CENTER_CAMERA_NAME) control_stream = pylot.operator_creator.add_pid_agent( pose_stream, waypoints_stream) extract_control_stream = erdos.ExtractStream(control_stream) time_to_decision_stream = pylot.operator_creator.add_time_to_decision( pose_stream, obstacles_stream) time_to_decision_loop_stream.set(time_to_decision_stream) return (camera_streams, pose_stream, global_trajectory_stream, open_drive_stream, point_cloud_stream, extract_control_stream)
def main(): # Create the first dataflow. ingest_stream = erdos.IngestStream() (map_stream, ) = erdos.connect(map.Map, erdos.OperatorConfig(name="Double"), [ingest_stream], function=double) extract_stream = erdos.ExtractStream(map_stream) node_handle = erdos.run_async() for t in range(5): send_msg = erdos.Message(erdos.Timestamp(coordinates=[t]), t) ingest_stream.send(send_msg) print("IngestStream: sent {send_msg}".format(send_msg=send_msg)) recv_msg = extract_stream.read() print("ExtractStream: received {recv_msg}".format(recv_msg=recv_msg)) time.sleep(1) node_handle.shutdown() erdos.reset() # Create a new dataflow. ingest_stream = erdos.IngestStream() (map_stream, ) = erdos.connect(map.Map, erdos.OperatorConfig(name="Square"), [ingest_stream], function=square) extract_stream = erdos.ExtractStream(map_stream) node_handle = erdos.run_async() for t in range(5): send_msg = erdos.Message(erdos.Timestamp(coordinates=[t]), t) ingest_stream.send(send_msg) print("IngestStream: sent {send_msg}".format(send_msg=send_msg)) recv_msg = extract_stream.read() print("ExtractStream: received {recv_msg}".format(recv_msg=recv_msg)) time.sleep(1) node_handle.shutdown()
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(): ingest_stream = erdos.IngestStream() (s, ) = erdos.connect(NoopOp, erdos.OperatorConfig(), [ingest_stream]) extract_stream = erdos.ExtractStream(s) erdos.run_async() timestamp = erdos.Timestamp(is_top=True) send_msg = erdos.WatermarkMessage(timestamp) print("IngestStream: sending {send_msg}".format(send_msg=send_msg)) ingest_stream.send(send_msg) assert ingest_stream.is_closed() recv_msg = extract_stream.read() print("ExtractStream: received {recv_msg}".format(recv_msg=recv_msg)) assert recv_msg.is_top assert extract_stream.is_closed()
def create_data_flow(): """ Create the challenge data-flow graph.""" track = get_track() camera_setups = create_camera_setups(track) camera_streams = {} for name in camera_setups: camera_streams[name] = erdos.IngestStream() can_bus_stream = erdos.IngestStream() global_trajectory_stream = erdos.IngestStream() open_drive_stream = erdos.IngestStream() if track != Track.ALL_SENSORS_HDMAP_WAYPOINTS: # We do not have access to the open drive map. Send top watermark. open_drive_stream.send( erdos.WatermarkMessage(erdos.Timestamp(coordinates=[sys.maxsize]))) if (track == Track.ALL_SENSORS or track == Track.ALL_SENSORS_HDMAP_WAYPOINTS): point_cloud_stream = erdos.IngestStream() else: point_cloud_stream = pylot.operator_creator.add_depth_estimation( camera_streams[LEFT_CAMERA_NAME], camera_streams[RIGHT_CAMERA_NAME], camera_setups[CENTER_CAMERA_NAME]) obstacles_stream = pylot.operator_creator.add_obstacle_detection( camera_streams[CENTER_CAMERA_NAME])[0] traffic_lights_stream = pylot.operator_creator.add_traffic_light_detector( camera_streams[TL_CAMERA_NAME]) waypoints_stream = pylot.operator_creator.add_waypoint_planning( can_bus_stream, open_drive_stream, global_trajectory_stream, None) if FLAGS.visualize_rgb_camera: pylot.operator_creator.add_camera_visualizer( camera_streams[CENTER_CAMERA_NAME], CENTER_CAMERA_NAME) control_stream = pylot.operator_creator.add_pylot_agent( can_bus_stream, waypoints_stream, traffic_lights_stream, obstacles_stream, point_cloud_stream, open_drive_stream, camera_setups[CENTER_CAMERA_NAME]) extract_control_stream = erdos.ExtractStream(control_stream) return (camera_streams, can_bus_stream, global_trajectory_stream, open_drive_stream, point_cloud_stream, extract_control_stream)
def main(): ingest_stream = erdos.IngestStream() (square_stream, ) = erdos.connect(Map, erdos.OperatorConfig(), [ingest_stream], function=square_msg) extract_stream = erdos.ExtractStream(square_stream) erdos.run_async() count = 0 while True: timestamp = erdos.Timestamp(coordinates=[count]) send_msg = erdos.Message(timestamp, count) print("IngestStream: sending {send_msg}".format(send_msg=send_msg)) ingest_stream.send(send_msg) recv_msg = extract_stream.read() print("ExtractStream: received {recv_msg}".format(recv_msg=recv_msg)) count += 1 time.sleep(1)
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('-i', '--interveal', default=1, type=int) parser.add_argument('-t', '--transport', default="tcp") parser.add_argument('-g', '--graph-file') args = parser.parse_args() """Creates and runs the dataflow graph.""" ingest_stream = erdos.IngestStream() (pong_stream, ) = erdos.connect(PongOp, erdos.OperatorConfig(), [ingest_stream]) extract_stream = erdos.ExtractStream(pong_stream) if args.graph_file is not None: erdos.run_async(args.graph_file) else: erdos.run_async() count = 0 payload = '0' * args.payload while True: msg = erdos.Message(erdos.Timestamp(coordinates=[count]), payload) t0 = datetime.datetime.now() ingest_stream.send(msg) #print("PingOp: sending {msg}".format(msg=msg)) count += 1 data = extract_stream.read() t1 = datetime.datetime.now() #print("PingOp: received {msg}".format(msg=data)) t = t1 - t0 print( f"erdos-{args.transport},{args.scenario},latency,{args.name},{args.payload},{data.timestamp.coordinates[0]},{t.microseconds}" ) time.sleep(args.interveal)
def create_data_flow(): """ Create the challenge data-flow graph.""" streams_to_send_top_on = [] time_to_decision_loop_stream = erdos.LoopStream() camera_setups = create_camera_setups() camera_streams = {} for name in camera_setups: camera_streams[name] = erdos.IngestStream() global_trajectory_stream = erdos.IngestStream() open_drive_stream = erdos.IngestStream() point_cloud_stream = erdos.IngestStream() imu_stream = erdos.IngestStream() gnss_stream = erdos.IngestStream() route_stream = erdos.IngestStream() if FLAGS.localization: pose_stream = pylot.operator_creator.add_localization( imu_stream, gnss_stream, route_stream) else: pose_stream = erdos.IngestStream() ground_obstacles_stream = erdos.IngestStream() ground_traffic_lights_stream = erdos.IngestStream() vehicle_id_stream = erdos.IngestStream() if not (FLAGS.perfect_obstacle_tracking or FLAGS.carla_localization): streams_to_send_top_on.append(vehicle_id_stream) if FLAGS.carla_obstacle_detection: obstacles_stream = ground_obstacles_stream elif any('efficientdet' in model for model in FLAGS.obstacle_detection_model_names): obstacles_stream = pylot.operator_creator.\ add_efficientdet_obstacle_detection( camera_streams[CENTER_CAMERA_NAME], time_to_decision_loop_stream)[0] streams_to_send_top_on.append(ground_obstacles_stream) else: obstacles_stream = pylot.operator_creator.add_obstacle_detection( camera_streams[CENTER_CAMERA_NAME], time_to_decision_loop_stream)[0] streams_to_send_top_on.append(ground_obstacles_stream) if FLAGS.carla_traffic_light_detection: traffic_lights_stream = ground_traffic_lights_stream camera_streams[TL_CAMERA_NAME] = erdos.IngestStream() streams_to_send_top_on.append(camera_streams[TL_CAMERA_NAME]) else: traffic_lights_stream = \ pylot.operator_creator.add_traffic_light_detector( camera_streams[TL_CAMERA_NAME]) # Adds an operator that finds the world location of the traffic lights. traffic_lights_stream = \ pylot.operator_creator.add_obstacle_location_finder( traffic_lights_stream, point_cloud_stream, pose_stream, camera_setups[TL_CAMERA_NAME]) streams_to_send_top_on.append(ground_traffic_lights_stream) obstacles_tracking_stream = pylot.component_creator.add_obstacle_tracking( camera_streams[CENTER_CAMERA_NAME], camera_setups[CENTER_CAMERA_NAME], obstacles_stream, depth_stream=point_cloud_stream, vehicle_id_stream=vehicle_id_stream, pose_stream=pose_stream, ground_obstacles_stream=ground_obstacles_stream, time_to_decision_stream=time_to_decision_loop_stream) if FLAGS.execution_mode == 'challenge-sensors': lanes_stream = pylot.operator_creator.add_lanenet_detection( camera_streams[LANE_CAMERA_NAME]) else: lanes_stream = erdos.IngestStream() streams_to_send_top_on.append(lanes_stream) prediction_stream = pylot.operator_creator.add_linear_prediction( obstacles_tracking_stream) waypoints_stream = pylot.component_creator.add_planning( None, pose_stream, prediction_stream, traffic_lights_stream, lanes_stream, open_drive_stream, global_trajectory_stream, time_to_decision_loop_stream) if pylot.flags.must_visualize(): control_display_stream, ingest_streams = \ pylot.operator_creator.add_visualizer( pose_stream=pose_stream, camera_stream=camera_streams[CENTER_CAMERA_NAME], tl_camera_stream=camera_streams[TL_CAMERA_NAME], point_cloud_stream=point_cloud_stream, obstacles_stream=obstacles_stream, traffic_lights_stream=traffic_lights_stream, tracked_obstacles_stream=obstacles_tracking_stream, waypoints_stream=waypoints_stream, lane_detection_stream=lanes_stream, prediction_stream=prediction_stream) streams_to_send_top_on += ingest_streams else: control_display_stream = None control_stream = pylot.operator_creator.add_pid_control( pose_stream, waypoints_stream) extract_control_stream = erdos.ExtractStream(control_stream) time_to_decision_stream = pylot.operator_creator.add_time_to_decision( pose_stream, obstacles_stream) time_to_decision_loop_stream.set(time_to_decision_stream) return (camera_streams, pose_stream, route_stream, global_trajectory_stream, open_drive_stream, point_cloud_stream, imu_stream, gnss_stream, extract_control_stream, control_display_stream, ground_obstacles_stream, ground_traffic_lights_stream, vehicle_id_stream, streams_to_send_top_on)
def create_data_flow(): """Creates a dataflow graph of operators. This is the place to add other operators (e.g., other detectors, behavior planning). """ streams_to_send_top_on = [] camera_setups = create_camera_setups() # Creates a dataflow stream for each camera. camera_streams = {} for name in camera_setups: camera_streams[name] = erdos.IngestStream() # Creates a stream on which the agent sends the high-level route the # agent must follow in the challenge. global_trajectory_stream = erdos.IngestStream() # Creates a stream on which the agent sends the open drive stream it # receives when it executes in the MAP track. open_drive_stream = erdos.IngestStream() # Creates a stream on which the agent sends point cloud messages it # receives from the LiDAR sensor. point_cloud_stream = erdos.IngestStream() imu_stream = erdos.IngestStream() gnss_stream = erdos.IngestStream() route_stream = erdos.IngestStream() time_to_decision_loop_stream = erdos.LoopStream() if FLAGS.localization: # Pylot localization is enabled. Add the localization operator to # the dataflow. The operator receives GNSS and IMU messages, and # uses an Extended Kalman Filter to compute poses. pose_stream = pylot.operator_creator.add_localization( imu_stream, gnss_stream, route_stream) else: # The agent either directly forwards the poses it receives from # the challenge, which are noisy, or the perfect poses if the # --perfect_localization flag is set. pose_stream = erdos.IngestStream() # Stream on which the obstacles are sent when the agent is using perfect # detection. perfect_obstacles_stream = erdos.IngestStream() if FLAGS.simulator_obstacle_detection: # Execute with perfect perception. In this configuration, the agent # directly gets the location of the other agents from the simulator. # This configuration is meant for testing and debugging. obstacles_stream = perfect_obstacles_stream elif any('efficientdet' in model for model in FLAGS.obstacle_detection_model_names): # Add an operator that runs EfficientDet to detect obstacles. obstacles_stream = pylot.operator_creator.\ add_efficientdet_obstacle_detection( camera_streams[CENTER_CAMERA_NAME], time_to_decision_loop_stream)[0] if not (FLAGS.evaluate_obstacle_detection or FLAGS.evaluate_obstacle_tracking): streams_to_send_top_on.append(perfect_obstacles_stream) else: # Add an operator that uses one of the Tensorflow model zoo # detection models. By default, we use FasterRCNN. obstacles_stream = pylot.operator_creator.add_obstacle_detection( camera_streams[CENTER_CAMERA_NAME], time_to_decision_loop_stream)[0] if not (FLAGS.evaluate_obstacle_detection or FLAGS.evaluate_obstacle_tracking): streams_to_send_top_on.append(perfect_obstacles_stream) # Stream on which the traffic lights are sent when the agent is # using perfect traffic light detection. perfect_traffic_lights_stream = erdos.IngestStream() if FLAGS.simulator_traffic_light_detection: # In this debug configuration, the agent is using perfectly located # traffic lights it receives directly from the simulator. Therefore, # there's no need to a traffic light detector. traffic_lights_stream = perfect_traffic_lights_stream camera_streams[TL_CAMERA_NAME] = erdos.IngestStream() streams_to_send_top_on.append(camera_streams[TL_CAMERA_NAME]) else: # Adds a traffic light detector operator, which uses the camera with # the small fov. traffic_lights_stream = \ pylot.operator_creator.add_traffic_light_detector( camera_streams[TL_CAMERA_NAME], time_to_decision_loop_stream) # Adds an operator that finds the world location of the traffic lights. # The operator synchronizes LiDAR point cloud readings with camera # frames, and uses them to compute the depth to traffic light bounding # boxes. traffic_lights_stream = \ pylot.operator_creator.add_obstacle_location_finder( traffic_lights_stream, point_cloud_stream, pose_stream, camera_setups[TL_CAMERA_NAME]) # We do not send perfectly located traffic lights in this # configuration. Therefore, ensure that the stream is "closed" # (i.e., send a top watermark) streams_to_send_top_on.append(perfect_traffic_lights_stream) vehicle_id_stream = erdos.IngestStream() if not (FLAGS.perfect_obstacle_tracking or FLAGS.perfect_localization): # The vehicle_id_stream is only used when perfect localization # or perfect obstacle tracking are enabled. streams_to_send_top_on.append(vehicle_id_stream) # Adds an operator for tracking detected agents. The operator uses the # frames from the center camera, and the bounding boxes found by the # obstacle detector operator. obstacles_tracking_stream = pylot.component_creator.add_obstacle_tracking( camera_streams[CENTER_CAMERA_NAME], camera_setups[CENTER_CAMERA_NAME], obstacles_stream, depth_stream=point_cloud_stream, vehicle_id_stream=vehicle_id_stream, pose_stream=pose_stream, ground_obstacles_stream=perfect_obstacles_stream, time_to_decision_stream=time_to_decision_loop_stream) if FLAGS.execution_mode == 'challenge-sensors': # The agent is running is sensors-only track. Therefore, we need # to add a lane detector because the agent does not have access to # the OpenDrive map. lanes_stream = pylot.operator_creator.add_lanenet_detection( camera_streams[LANE_CAMERA_NAME]) else: # The lanes stream is not used when running in the Map track. # We add the stream to the list of streams that are not used, and # must be manually "closed" (i.e., send a top watermark). lanes_stream = erdos.IngestStream() streams_to_send_top_on.append(lanes_stream) # The agent uses a linear predictor to compute future trajectories # of the other agents. prediction_stream, _, _ = pylot.component_creator.add_prediction( obstacles_tracking_stream, vehicle_id_stream, time_to_decision_loop_stream, pose_stream=pose_stream) # Adds a planner to the agent. The planner receives the pose of # the ego-vehicle, detected traffic lights, predictions for other # agents, the route the agent must follow, and the open drive data if # the agent is executing in the Map track, or detected lanes if it is # executing in the Sensors-only track. waypoints_stream = pylot.component_creator.add_planning( None, pose_stream, prediction_stream, traffic_lights_stream, lanes_stream, open_drive_stream, global_trajectory_stream, time_to_decision_loop_stream) if pylot.flags.must_visualize(): # Adds a visualization dataflow operator if any of the # --visualize_* is enabled. The operator creates a pygame window # in which the different sensors, detections can be visualized. control_display_stream, ingest_streams = \ pylot.operator_creator.add_visualizer( pose_stream=pose_stream, camera_stream=camera_streams[CENTER_CAMERA_NAME], tl_camera_stream=camera_streams[TL_CAMERA_NAME], point_cloud_stream=point_cloud_stream, obstacles_stream=obstacles_stream, traffic_lights_stream=traffic_lights_stream, tracked_obstacles_stream=obstacles_tracking_stream, waypoints_stream=waypoints_stream, lane_detection_stream=lanes_stream, prediction_stream=prediction_stream) streams_to_send_top_on += ingest_streams else: control_display_stream = None # Adds a controller which tries to follow the waypoints computed # by the planner. control_stream = pylot.component_creator.add_control( pose_stream, waypoints_stream) # The controller returns a stream of commands (i.e., throttle, steer) # from which the agent can read the command it must return to the # challenge. extract_control_stream = erdos.ExtractStream(control_stream) pylot.component_creator.add_evaluation(vehicle_id_stream, pose_stream, imu_stream) # Operator that computes how much time each component gets to execute. # This is needed in Pylot, but can be ignored when running in challenge # mode. time_to_decision_stream = pylot.operator_creator.add_time_to_decision( pose_stream, obstacles_stream) time_to_decision_loop_stream.set(time_to_decision_stream) return (camera_streams, pose_stream, route_stream, global_trajectory_stream, open_drive_stream, point_cloud_stream, imu_stream, gnss_stream, extract_control_stream, control_display_stream, perfect_obstacles_stream, perfect_traffic_lights_stream, vehicle_id_stream, streams_to_send_top_on)
def driver(): ingest_stream = erdos.IngestStream() (square_stream, ) = erdos.connect(SquareOp, [ingest_stream]) extract_stream = erdos.ExtractStream(square_stream) return ingest_stream, extract_stream