def run_graph(argv): """Sums the squares of 2 numbers. """ graph = erdos.graph.get_current_graph() sub_graph = graph.add(SumSquaresGraph, name="sum_squares") # Add operators int1 = graph.add(IntegerOp, name="int1", init_args={ "number": 1, "stream_name": "int1_out" }, setup_args={"stream_name": "int1_out"}) int2 = graph.add(IntegerOp, name="int2", init_args={ "number": 2, "stream_name": "int2_out" }, setup_args={"stream_name": "int2_out"}) square_op = graph.add(SquareOp, name="default_square") # Connect operators graph.connect([int1, int2], [sub_graph]) graph.connect([sub_graph], [square_op]) # Execute graph graph.execute(FLAGS.framework)
def run_graph(spin): graph = erdos.graph.get_current_graph() first = graph.add(FirstOp, name='first') second = graph.add(SecondOp, name='second', init_args={'spin': spin}) graph.connect([first], [second]) graph.connect([second], [first]) graph.execute(FLAGS.framework)
def run_graph(n_pub, n_sub, spin): graph = erdos.graph.get_current_graph() # Add publishers publishers = [] for i in range(n_pub): pub = graph.add(PublisherOp, name='publisher_%d' % i) publishers.append(pub) # Add subscribers subscribers = [] for i in range(n_sub): sub = graph.add( SubscriberOp, name='subscriber_%d' % i, init_args={ 'num_pub_ops': n_pub, 'spin': spin }) subscribers.append(sub) # Connect operators graph.connect(publishers, subscribers) # Execute graph graph.execute(FLAGS.framework)
def run_graph(spin): graph = erdos.graph.get_current_graph() first_graph = graph.add(FirstGraph, name='first_graph') second_graph = graph.add(SecondGraph, name='second_graph', setup_args={'spin': spin}) graph.connect([first_graph], [second_graph]) graph.connect([second_graph], [first_graph]) graph.execute(FLAGS.framework)
def main(argv): graph = erdos.graph.get_current_graph() front_locations = FLAGS.front_camera_locations.split(',') for location in front_locations: analyze_frequency(graph, 'camera_' + location + '.log', 'jitter_camera_' + location + '.log') graph.execute(FLAGS.framework)
def main(argv): # Set up graph graph = erdos.graph.get_current_graph() # Add operators camera = graph.add( CameraOperator, name='camera', setup_args={'op_name': 'camera'}) detector = graph.add( DetectionOperator, name='detector', init_args={ 'min_runtime_us': 1, 'max_runtime_us': 100, 'min_det_objs': 3, 'max_det_objs': 15 }, setup_args={'op_name': 'detector'}) lidar = graph.add( LidarOperator, name='lidar', init_args={'num_points': 100000}, setup_args={'op_name': 'lidar'}) tracker = graph.add( TrackerOperator, name='tracker', init_args={ 'min_runtime_us': 1, 'max_runtime_us': 100 }, setup_args={'op_name': 'tracker'}) segmentation = graph.add( SegmentationOperator, name='seg', init_args={ 'min_runtime_us': 1, 'max_runtime_us': 100 }, setup_args={'op_name': 'seg'}) slam = graph.add( SLAMOperator, name='SLAM', init_args={ 'min_runtime_us': 1, 'max_runtime_us': 100 }) # Connect operators graph.connect([camera], [detector, segmentation]) graph.connect([camera, detector], [tracker]) graph.connect([lidar, tracker], [slam]) # Execute graph graph.execute(FLAGS.framework)
def main(argv): # Create the graph. graph = erdos.graph.get_current_graph() construct_graph(graph) # Execute the graph. graph.execute("ros") try: while True: pass except KeyboardInterrupt: pass
def main(): # Create operators graph = erdos.graph.get_current_graph() car_racing_op = graph.add(CarRacingOp, name='car_racing') action_op = graph.add(ActionOp, name='action') # Add connect streams to operators for cyclical graph graph.connect([car_racing_op], [action_op]) graph.connect([action_op], [car_racing_op]) # Execute graph graph.execute("ray")
def main(argv): # Set up graph graph = erdos.graph.get_current_graph() # Add operators input_op = graph.add(InputOperator, name='input_op') push_op = graph.add(PushOperator, name='push_op') # Connect graph graph.connect([input_op], [push_op]) # Execute graph graph.execute(FLAGS.framework)
def main(argv): # Set up graph graph = erdos.graph.get_current_graph() if FLAGS.test_case == 'service': from beginner_tutorials.srv import * from beginner_tutorials.srv import AddTwoIntsRequest, AddTwoInts, AddTwoIntsResponse # Add operators add_two_ints_input_op = graph.add(AddTwoIntsInputOp, name='add_op') ros_service_op = graph.add(ROSServiceOp, name='ros_service', init_args={ 'service_name': 'add_two_ints', 'srv_type': AddTwoInts }, setup_args={ 'srv_ret_type': AddTwoIntsResponse, 'op_name': 'add_two_ints' }) # Connect graph graph.connect([add_two_ints_input_op], [ros_service_op]) elif FLAGS.test_case == 'publisher': data_generator_op = graph.add(DataGeneratorOp, name='data_gen') ros_publisher_op = graph.add(ROSPublisherOp, name='ros_publisher', init_args={ 'ros_topic': 'my_topic', 'data_type': String }) graph.connect([data_generator_op], [ros_publisher_op]) elif FLAGS.test_case == 'subscriber': ros_subscriber_op = graph.add( ROSSubscriberOp, name='ros_subscriber', init_args={ 'ros_topics_type': [('/my_topic', String, 'erdos_stream')] }, setup_args={ 'ros_topics_type': [('/my_topic', String, 'erdos_stream')] }) echo_op = graph.add(EchoOp, name='echo_op') graph.connect([ros_subscriber_op], [echo_op]) else: raise ValueError('Unexpected test_case {}'.format(FLAGS.test_case)) # Execute graph graph.execute(FLAGS.framework)
def run_graph(): """Sums the squares of 2 numbers. """ # Set up graph graph = erdos.graph.get_current_graph() # Add operators sum_squares_graph = graph.add(SumSquaresGraph, name='sum_squares') square_op = graph.add(SquareOp, name='square') # Connect Operators graph.connect([sum_squares_graph], [square_op]) # Execute graph graph.execute(FLAGS.framework)
def main(argv): # Set up the graph. graph = erdos.graph.get_current_graph() # Add the operators. source_op_1 = graph.add(SourceOperator, name = "FirstOperator") debug_op_1 = graph.add(DebugOperator, name = "DebugOperator") sink_op_1 = graph.add(SinkOperator, name = "SinkOperator") # Connect the operators. graph.connect([source_op_1], [debug_op_1]) graph.connect([debug_op_1], [sink_op_1]) # Execute the graph. graph.execute('ray')
def main(argv): graph = erdos.graph.get_current_graph() publish_op_one = graph.add(PublisherOperator, name='publish_op_one', init_args={'text': 'publish-one'}) publish_op_two = graph.add(PublisherOperator, name='publish_op_two', init_args={'text': 'publish-two'}) subscriber_with_print_op = graph.add(SubscriberWithPrintOperator, name='subscriber_with_print') subscriber_without_print_op = graph.add(SubscriberWithoutPrintOperator, name='subscriber_without_print') graph.connect([publish_op_one], [subscriber_with_print_op]) graph.connect([publish_op_two], [subscriber_without_print_op]) graph.execute(FLAGS.framework)
def main(argv): # Set up the graph. graph = erdos.graph.get_current_graph() # Add the operators. source_op = graph.add(FirstOperator, name="gen_op", init_args={'batch_size': 10}) sum_op = graph.add(SecondOperator, name="sum_op") assert_op = graph.add(ThirdOperator, name="assert_op") # Connect the operators. graph.connect([source_op], [sum_op]) graph.connect([sum_op], [assert_op]) # Execute the graph. graph.execute('ray')
def run_graph(argv): # Extract variables num_messages = int(FLAGS.num_msg) fps = int(FLAGS.fps) fail_time = int(FLAGS.fail_time) state_size = int(FLAGS.state_size) checkpoint_freq = int(FLAGS.checkpoint_freq) # Define graph graph = erdos.graph.get_current_graph() source_op = graph.add( Source, name='source', init_args={'num_messages': num_messages, 'fps': fps, 'checkpoint_freq': checkpoint_freq} ) failure_op = graph.add( FailureOperator, name='primary_failure', init_args={'state_size': state_size, 'checkpoint_freq': checkpoint_freq}) sink_op = graph.add( Sink, name='sink', init_args={'state_size': state_size, 'checkpoint_freq': checkpoint_freq} ) controller_op = graph.add( ControllerOperator, name='controller', init_args={'pre_failure_time_elapse_s': fail_time}) # Connect Graph graph.connect([source_op], [failure_op]) graph.connect([failure_op], [sink_op]) graph.connect([sink_op], [controller_op]) graph.connect([controller_op], [source_op, failure_op, sink_op]) # Execute Graph graph.execute(FLAGS.framework)
def main(argv): # Define graph graph = erdos.graph.get_current_graph() # Add camera and lidar driver operators to the data-flow graph. (bgr_camera_setup, carla_op, camera_ops, lidar_ops) = add_driver_operators(graph, auto_pilot=FLAGS.carla_auto_pilot) # Add debugging operators (e.g., visualizers) to the data-flow graph. add_debugging_component(graph, carla_op, camera_ops, lidar_ops) if FLAGS.use_perfect_perception: # Add operators that use ground information. (obj_det_ops, traffic_light_det_ops, lane_det_ops, segmentation_ops) = add_perfect_perception_component( graph, bgr_camera_setup, 'perfect_detector_output', carla_op, camera_ops) else: # Add detectors. (obj_det_ops, traffic_light_det_ops, lane_det_ops) = add_detection_component(graph, bgr_camera_setup, camera_ops, carla_op) # Add segmentation operators. segmentation_ops = add_segmentation_component(graph, camera_ops) add_ground_eval_ops(graph, obj_det_ops, camera_ops) # Add the behaviour planning agent operator. agent_op = add_agent_op(graph, carla_op, traffic_light_det_ops, obj_det_ops, segmentation_ops, lane_det_ops, bgr_camera_setup) # Add planning operators. goal_location = (234.269989014, 59.3300170898, 39.4306259155) goal_orientation = (1.0, 0.0, 0.22) add_planning_component(graph, goal_location, goal_orientation, carla_op, agent_op, city_name='Town{:02d}'.format(FLAGS.carla_town)) graph.execute(FLAGS.framework)
def main(argv): graph = erdos.graph.get_current_graph() input_ops = [] for i in range(0, 2): input_op = graph.add(InputOperator, name='input' + str(i)) input_ops.append(input_op) sync_op = graph.add(SynchronizerLastDataOperator, name='synchronizer') # sync_op = SynchronizerBestDataOperator() # sync_op = SynchronizerDataWithinLimitOperator(500) # TODO(ionel): Implement! # sync_op = SynchronizerByDeadlineOperator() # sync_op = SynchronizerBestDataWithDelay() graph.connect(input_ops, [sync_op]) graph.execute(FLAGS.framework)
def main(argv): # Set up the graph. graph = erdos.graph.get_current_graph() # Add the operators. source_op_1 = graph.add( SourceOperator, name="FirstOperator", init_args={ 'batch_size': BATCH_SIZE, 'send_batch': lambda x: x % 2 == True, 'output_stream_name': 'first-stream', }, setup_args={ 'output_stream_name': 'first-stream', }) source_op_2 = graph.add( SourceOperator, name="SecondOperator", init_args={ 'batch_size': BATCH_SIZE, 'send_batch': lambda x: x % 2 == False, 'output_stream_name': 'second-stream', }, setup_args={ 'output_stream_name': 'second-stream', }) release_op = graph.add( EarlyReleaseOperator, name="ReleaseOperator", init_args={ 'output_stream_name': 'release-stream', }, setup_args={ 'output_stream_name': 'release-stream', }) sink_op = graph.add(SinkOperator, name="SinkOperator") # Connect the operators. graph.connect([source_op_1, source_op_2], [release_op]) graph.connect([release_op], [sink_op]) # Execute the graph. graph.execute('ray')
def main(argv): """Sums the squares of 2 numbers. """ # Set up graph graph = erdos.graph.get_current_graph() # Add operators int1 = graph.add(IntegerOp, name='int1', init_args={'number': 1}) int2 = graph.add(IntegerOp, name='int2', init_args={'number': 2}) square1 = graph.add(SquareOp, name='square') square2 = graph.add(SquareOp, name='square2') sum = graph.add(SumOp, name='sum') # Connect operators graph.connect([int1], [square1]) graph.connect([int2], [square2]) graph.connect([square1, square2], [sum]) # Execute graph graph.execute(FLAGS.framework)
def main(argv): graph = erdos.graph.get_current_graph() front_locations = FLAGS.front_camera_locations.split(',') side_locations = [] if FLAGS.side_cameras: side_locations = ['side_left', 'side_right'] rear_locations = [] if FLAGS.rear_cameras: rear_locations = ['rear_left', 'rear_center', 'rear_right'] tracker_ops = [] lane_det_ops = [] traffic_light_det_ops = [] intersection_det_ops = [] traffic_sign_det_ops = [] for location in front_locations: ops = add_front_camera_processing_graph(graph, location) tracker_ops.append(ops[0]) lane_det_ops.append(ops[1]) traffic_light_det_ops.append(ops[2]) intersection_det_ops.append(ops[3]) traffic_sign_det_ops.append(ops[4]) for location in side_locations: ops = add_side_camera_processing_graph(graph, location) tracker_ops.append(ops[0]) lane_det_ops.append(ops[1]) traffic_light_det_ops.append(ops[2]) intersection_det_ops.append(ops[3]) traffic_sign_det_ops.append(ops[4]) for location in rear_locations: ops = add_rear_camera_processing_graph(graph, location) tracker_ops.append(ops[0]) # TODO(ionel): Plugin mapping operator. # mapping_op = graph.add( # MappingOperator, # name='mapping', # init_args={'buffer_logs': FLAGS.buffer_logs}) # 1 mission planner operator. mission_planner_op = graph.add(MissionPlannerOperator, name='mission_planner', init_args={ 'min_runtime_us': 1, 'max_runtime_us': 100, 'buffer_logs': FLAGS.buffer_logs }) # 1 motion planner operator. motion_planner_op = graph.add(MotionPlannerOperator, name='motion_planner', init_args={ 'min_runtime_us': 1, 'max_runtime_us': 100, 'buffer_logs': FLAGS.buffer_logs }) (slam_op, fusion_op) = add_localization_graph(graph, front_locations, tracker_ops) prediction_op = add_prediction_graph(graph, tracker_ops)[0] graph.connect([slam_op], [mission_planner_op]) graph.connect([mission_planner_op, fusion_op, prediction_op] + lane_det_ops + traffic_light_det_ops + intersection_det_ops + traffic_sign_det_ops, [motion_planner_op]) graph.execute(FLAGS.framework)
def main(argv): # Get default data-flow graph. graph = erdos.graph.get_current_graph() camera_setups, top_down_segmented_camera_setup = create_camera_setups() lidar_setups = create_lidar_setups() # Add operator that interacts with the Carla simulator. (carla_op, camera_ops, lidar_ops) = pylot.operator_creator.create_driver_ops( graph, camera_setups, lidar_setups, auto_pilot=FLAGS.carla_auto_pilot) # Add an operator that logs BGR frames and segmented frames. camera_log_ops = [] if FLAGS.log_cameras: camera_log_ops = [ pylot.operator_creator.create_camera_logger_op(graph)] lidar_log_ops = [] if FLAGS.log_lidar: lidar_log_ops = [pylot.operator_creator.create_lidar_logger_op(graph)] chauffeur_log_ops = [] if FLAGS.log_chauffeur: chauffeur_log_ops = [pylot.operator_creator.create_chauffeur_logger_op( graph, top_down_segmented_camera_setup, pylot.utils.TOP_DOWN_SEGMENTED_CAMERA_NAME)] # Connect the camera logging ops with the camera ops. graph.connect(camera_ops, camera_log_ops + chauffeur_log_ops) graph.connect(lidar_ops, lidar_log_ops) detector_ops, bbox_logger_ops = add_perfect_detection_component( graph, camera_setups, carla_op, camera_ops) tracking_ops = add_perfect_tracking_component(graph, carla_op) trajectory_log_ops = [] if FLAGS.log_trajectories: trajectory_log_ops = [ pylot.operator_creator.create_trajectory_logger_op(graph)] graph.connect(tracking_ops, trajectory_log_ops + chauffeur_log_ops) multiple_object_tracker_logger_op = [ pylot.operator_creator.create_multiple_object_tracker_logger_op(graph)] graph.connect(detector_ops, multiple_object_tracker_logger_op) # Add visual operators. pylot.operator_creator.add_visualization_operators( graph, camera_ops, lidar_ops, tracking_ops, pylot.utils.CENTER_CAMERA_NAME, pylot.utils.DEPTH_CAMERA_NAME, pylot.utils.FRONT_SEGMENTED_CAMERA_NAME, pylot.utils.TOP_DOWN_SEGMENTED_CAMERA_NAME, top_down_segmented_camera_setup) if FLAGS.carla_auto_pilot: # We do not need planning and agent ops if we're running in # auto pilot mode. Instead, we insert a synchronizing operator # that only sends back a command when all the operators in their # data-flow have finished processing a message. sync_op = graph.add(SynchronizerOp, name='sync_op') graph.connect( camera_ops + lidar_ops + camera_log_ops + lidar_log_ops + detector_ops + bbox_logger_ops + chauffeur_log_ops, [sync_op]) graph.connect([sync_op], [carla_op]) graph.connect([carla_op], chauffeur_log_ops) else: raise ValueError("Must be in auto pilot mode. Pass --carla_auto_pilot") graph.execute("ros")
def main(argv): # Define graph graph = erdos.graph.get_current_graph() camera_setups = create_camera_setups() lidar_setups = create_lidar_setups() # Add operator that interacts with the Carla simulator. (carla_op, camera_ops, lidar_ops) = pylot.operator_creator.create_driver_ops( graph, camera_setups, lidar_setups, auto_pilot=FLAGS.carla_auto_pilot) # Add visual operators. pylot.operator_creator.add_visualization_operators( graph, camera_ops, lidar_ops, CENTER_CAMERA_NAME, DEPTH_CAMERA_NAME) # Add an operator that logs BGR frames and segmented frames. camera_log_ops = [pylot.operator_creator.create_camera_logger_op(graph)] lidar_log_ops = [pylot.operator_creator.create_lidar_logger_op(graph)] # Connect the camera logging ops with the camera ops. graph.connect(camera_ops, camera_log_ops) graph.connect(lidar_ops, lidar_log_ops) detector_ops, bbox_logger_ops = add_perfect_detection_component( graph, camera_setups, carla_op, camera_ops) if FLAGS.carla_auto_pilot: # We do not need planning and agent ops if we're running in # auto pilot mode. Instead, we insert a synchronizing operator # that only sends back a command when all the operators in their # data-flow have finished processing a message. sync_op = graph.add(SynchronizerOp, name='sync_op') graph.connect( camera_ops + lidar_ops + camera_log_ops + lidar_log_ops + detector_ops + bbox_logger_ops, [sync_op]) graph.connect([sync_op], [carla_op]) else: # Add agent that uses ground data to drive around. agent_op = pylot.operator_creator.create_ground_agent_op(graph) graph.connect([carla_op], [agent_op]) graph.connect([agent_op], [carla_op]) goal_location = (234.269989014, 59.3300170898, 39.4306259155) goal_orientation = (1.0, 0.0, 0.22) if '0.8' in FLAGS.carla_version: planning_op = pylot.operator_creator.create_legacy_planning_op( graph, 'Town{:02d}'.format(FLAGS.carla_town), goal_location, goal_orientation) elif '0.9' in FLAGS.carla_version: planning_op = pylot.operator_creator.create_planning_op( graph, goal_location) else: raise ValueError('Unexpected Carla version') graph.connect([carla_op], [planning_op]) graph.connect([planning_op], [agent_op]) graph.execute(FLAGS.framework)
def main(argv): # Define graph graph = erdos.graph.get_current_graph() source_op = graph.add(Source, name='source') flux_ingress_op = graph.add( FluxIngressOperator, name='flux_ingress', init_args={'output_stream_name': 'ingress_out'}, setup_args={'output_stream_name': 'ingress_out'}) flux_primary_consumer_op = graph.add(FluxConsumerOperator, name='flux_primary_consumer', init_args={ 'replica_num': 0, 'output_stream_name': 'primary_data_stream', 'ack_stream_name': 'primary_ack' }, setup_args={ 'output_stream_name': 'primary_data_stream', 'ack_stream_name': 'primary_ack' }) flux_secondary_consumer_op = graph.add(FluxConsumerOperator, name='flux_secondary_consumer', init_args={ 'replica_num': 1, 'output_stream_name': 'secondary_data_stream', 'ack_stream_name': 'secondary_ack' }, setup_args={ 'output_stream_name': 'secondary_data_stream', 'ack_stream_name': 'secondary_ack' }) primary_failure_op = graph.add( FailureOperator, name='primary_failure', init_args={ 'output_stream_name': 'primary_failure', 'replica_num': 0 }, setup_args={'output_stream_name': 'primary_failure'}) secondary_failure_op = graph.add( FailureOperator, name='secondary_failure', init_args={ 'output_stream_name': 'secondary_failure', 'replica_num': 1 }, setup_args={'output_stream_name': 'secondary_failure'}) flux_primary_producer_op = graph.add( FluxProducerOperator, name='flux_primary_producer', init_args={ 'replica_num': 0, 'output_stream_name': 'primary_producer' }, setup_args={'output_stream_name': 'primary_producer'}) flux_secondary_producer_op = graph.add( FluxProducerOperator, name='flux_secondary_producer', init_args={ 'replica_num': 1, 'output_stream_name': 'secondary_producer' }, setup_args={'output_stream_name': 'secondary_producer'}) flux_egress_op = graph.add(FluxEgressOperator, name='flux_egress', init_args={ 'output_stream_name': 'egress_out', 'ack_stream_name': 'ergress_ack' }, setup_args={ 'output_stream_name': 'egress_out', 'ack_stream_name': 'ergress_ack' }) sink_op = graph.add(Sink, name='sink') controller_op = graph.add(ControllerOperator, name='controller', init_args={'pre_failure_time_elapse_s': 3}) graph.connect([source_op], [flux_ingress_op]) graph.connect([flux_ingress_op], [flux_primary_consumer_op, flux_secondary_consumer_op]) graph.connect([flux_primary_consumer_op, flux_secondary_consumer_op], [flux_ingress_op]) graph.connect([flux_primary_consumer_op], [primary_failure_op]) graph.connect([flux_secondary_consumer_op], [secondary_failure_op]) graph.connect([primary_failure_op], [flux_primary_producer_op]) graph.connect([secondary_failure_op], [flux_secondary_producer_op]) graph.connect([flux_primary_producer_op, flux_secondary_producer_op], [flux_egress_op]) graph.connect([flux_egress_op], [flux_secondary_producer_op, sink_op]) graph.connect([controller_op], [ flux_ingress_op, flux_primary_consumer_op, flux_secondary_consumer_op, flux_egress_op ] + [primary_failure_op, secondary_failure_op]) graph.execute(FLAGS.framework)
def run_graph(spin): graph = erdos.graph.get_current_graph() pub = graph.add(PublisherOp, name='publisher') sub = graph.add(SubscriberOp, name='subscriber', init_args={'spin': spin}) graph.connect([pub], [sub]) graph.execute(FLAGS.framework)
def main(argv): # Define graph graph = erdos.graph.get_current_graph() logging_ops = [] # Add an operator that logs RGB frames and segmented frames. camera_logger_op = graph.add(CameraLoggerOp, name='camera_logger_op', init_args={ 'flags': FLAGS, 'log_file_name': FLAGS.log_file_name, 'csv_file_name': FLAGS.csv_log_file_name }) logging_ops.append(camera_logger_op) rgb_camera_setup = ('front_rgb_camera', 'SceneFinal', (FLAGS.carla_camera_image_width, FLAGS.carla_camera_image_height), (2.0, 0.0, 1.4)) camera_setups = [rgb_camera_setup] # Depth camera is required to map from 3D object bounding boxes # to 2D. depth_camera_name = 'front_depth_camera' depth_camera_setup = (depth_camera_name, 'Depth', (FLAGS.carla_camera_image_width, FLAGS.carla_camera_image_height), (2.0, 0.0, 1.4)) camera_setups.append(depth_camera_setup) # Add operator that converts from 3D bounding boxes # to 2D bouding boxes. ground_object_logger_op = graph.add(GroundTruthObjectLoggerOp, name='ground_truth_obj_logger', init_args={ 'rgb_camera_setup': rgb_camera_setup, 'flags': FLAGS, 'log_file_name': FLAGS.log_file_name, 'csv_file_name': FLAGS.csv_log_file_name }) logging_ops.append(ground_object_logger_op) # Record segmented frames as well. The CameraLoggerOp records them. segmentation_camera_setup = ('front_semantic_camera', 'SemanticSegmentation', (FLAGS.carla_camera_image_width, FLAGS.carla_camera_image_height), (2.0, 0.0, 1.4)) camera_setups.append(segmentation_camera_setup) # Add operator that interacts with the Carla simulator. carla_op = add_carla_op(graph, camera_setups) # Add agent that uses ground data to drive around. goal_location = (234.269989014, 59.3300170898, 39.4306259155) goal_orientation = (1.0, 0.0, 0.22) agent_op = add_ground_agent_op(graph, carla_op, goal_location, goal_orientation) # Connect the operators. graph.connect([carla_op], [agent_op]) graph.connect([agent_op], [carla_op]) graph.connect([carla_op], logging_ops) graph.execute(FLAGS.framework)
def main(argv): # Define graph graph = erdos.graph.get_current_graph() rgb_camera_setup = (RGB_CAMERA_NAME, 'SceneFinal', (FLAGS.carla_camera_image_width, FLAGS.carla_camera_image_height), (2.0, 0.0, 1.4)) camera_setups = [ rgb_camera_setup, (DEPTH_CAMERA_NAME, 'Depth', (FLAGS.carla_camera_image_width, FLAGS.carla_camera_image_height), (2.0, 0.0, 1.4)), (SEGMENTED_CAMERA_NAME, 'SemanticSegmentation', (FLAGS.carla_camera_image_width, FLAGS.carla_camera_image_height), (2.0, 0.0, 1.4)) ] # Add operators to the graph. carla_op = add_carla_op(graph, camera_setups) # Add visual operators. add_visualization_operators(graph, carla_op) # Add recording operators. add_recording_operators(graph, carla_op) # XXX(ionel): This planner is not currently in use. # planner_op = PlannerOperator('Town01', goal_location, goal_orientation) # planner_streams = planner_op([carla_op.get_output_stream('vehicle_pos')]) # control_streams = control_op(planner_streams) segmentation_ops = [] if FLAGS.segmentation_drn: segmentation_op = add_segmentation_drn_op(graph, carla_op) segmentation_ops.append(segmentation_op) if FLAGS.evaluate_segmentation: eval_segmentation_op = add_segmentation_eval_op( graph, carla_op, segmentation_op, SEGMENTED_CAMERA_NAME, 'segmented_stream') if FLAGS.segmentation_dla: segmentation_op = add_segmentation_dla_op(graph, carla_op) segmentation_ops.append(segmentation_op) if FLAGS.evaluate_segmentation: eval_segmentation_op = add_segmentation_eval_op( graph, carla_op, segmentation_op, SEGMENTED_CAMERA_NAME, 'segmented_stream') if FLAGS.eval_ground_truth_segmentation: eval_ground_truth_segmentation_op = add_segmentation_ground_eval_op( graph, carla_op, SEGMENTED_CAMERA_NAME) # This operator evaluates the temporal decay of the ground truth of # object detection across timestamps. if FLAGS.eval_ground_truth_object_detection: eval_ground_truth_detector_op = add_eval_ground_truth_detector_op( graph, carla_op, rgb_camera_setup, DEPTH_CAMERA_NAME) obj_detector_ops = [] if FLAGS.obj_detection: obj_detector_ops = add_detector_ops(graph, carla_op) if FLAGS.evaluate_obj_detection: obstacle_accuracy_op = add_obstacle_accuracy_op( graph, obj_detector_ops, carla_op, rgb_camera_setup, DEPTH_CAMERA_NAME) if FLAGS.obj_tracking: tracker_op = add_object_tracking_op(graph, carla_op, obj_detector_ops) if FLAGS.fusion: (fusion_op, fusion_verification_op) = add_fusion_ops(graph, carla_op, obj_detector_ops) traffic_light_det_ops = [] if FLAGS.traffic_light_det: traffic_light_det_ops.append(add_traffic_light_op(graph, carla_op)) lane_detection_ops = [] if FLAGS.lane_detection: lane_detection_ops.append(add_lane_detection_op(graph, carla_op)) agent_op = None if FLAGS.ground_agent_operator: agent_op = add_ground_agent_op(graph, carla_op) else: # TODO(ionel): The ERDOS agent doesn't use obj tracker and fusion. agent_op = add_erdos_agent_op(graph, carla_op, DEPTH_CAMERA_NAME, segmentation_ops, obj_detector_ops, traffic_light_det_ops, lane_detection_ops) goal_location = (234.269989014, 59.3300170898, 39.4306259155) goal_orientation = (1.0, 0.0, 0.22) waypointer_op = add_waypointer_op(graph, carla_op, agent_op, goal_location, goal_orientation) graph.execute(FLAGS.framework)
def main(argv): graph = erdos.graph.get_current_graph() data_gen_op = graph.add(DataGeneratorOp, name='data_gen_op') if FLAGS.where_test: where_op = graph.add(WhereOp, name='where_op', init_args={ 'where_lambda': lambda msg: msg.data % 2 == 0, 'output_stream_name': 'where_stream' }, setup_args={ 'filter_stream_lambda': lambda stream: stream.name == 'data_stream', 'output_stream_name': 'where_stream' }) log_op = graph.add(LogOp, name='where_log_op') graph.connect([data_gen_op], [where_op]) graph.connect([where_op], [log_op]) if FLAGS.map_test: map_op = graph.add(MapOp, name='map_op', init_args={ 'map_lambda': lambda msg: msg.data * msg.data, 'output_stream_name': 'map_stream' }, setup_args={ 'filter_stream_lambda': lambda stream: stream.name == 'data_stream', 'output_stream_name': 'map_stream' }) log_op = graph.add(LogOp, name='map_log_op') graph.connect([data_gen_op], [map_op]) graph.connect([map_op], [log_op]) if FLAGS.concat_test: concat_op = graph.add( ConcatOp, name='concat_op', init_args={'output_stream_name': 'concat_stream'}, setup_args={'output_stream_name': 'concat_stream'}) log_op = graph.add(LogOp, name='concat_log_op') graph.connect([data_gen_op], [concat_op]) graph.connect([concat_op], [log_op]) if FLAGS.map_many_test: map_many_op = graph.add( MapManyOp, name='map_many_op', init_args={'output_stream_name': 'flat_stream'}, setup_args={ 'filter_stream_lambda': lambda stream: stream.name == 'list_data_stream', 'output_stream_name': 'flat_stream' }) log_op = graph.add(LogOp, name='map_many_log_op') graph.connect([data_gen_op], [map_many_op]) graph.connect([map_many_op], [log_op]) if FLAGS.unzip_test: unzip_op = graph.add( UnzipOp, name='unzip_op', init_args={ 'output_stream_name1': 'unzip_left_stream', 'output_stream_name2': 'unzip_right_stream', }, setup_args={ 'output_stream_name1': 'unzip_left_stream', 'output_stream_name2': 'unzip_right_stream', 'filter_stream_lambda': lambda stream: stream.name == 'tuple_data_stream' }) log_op = graph.add(LogOp, name='unzip_log_op') graph.connect([data_gen_op], [unzip_op]) graph.connect([unzip_op], [log_op]) if FLAGS.counting_window_test: window_op = graph.add(WindowOp, name='counting_window_op', init_args={ 'output_stream_name': 'window_stream', 'assigner': CountWindowAssigner(2), 'trigger': CountWindowTrigger(2), 'processor': SumWindowProcessor() }, setup_args={ 'output_stream_name': 'window_stream', 'filter_stream_lambda': lambda stream: stream.name == 'data_stream' }) log_op = graph.add(LogOp, name='window_log_op') graph.connect([data_gen_op], [window_op]) graph.connect([window_op], [log_op]) if FLAGS.tumbling_window_test: window_op = graph.add(WindowOp, name='tumbling_window_op', init_args={ 'output_stream_name': 'window_stream', 'assigner': TumblingWindowAssigner(2000), 'trigger': TimeWindowTrigger(), 'processor': SumWindowProcessor() }, setup_args={ 'output_stream_name': 'window_stream', 'filter_stream_lambda': lambda stream: stream.name == 'data_stream' }) log_op = graph.add(LogOp, name='window_log_op') graph.connect([data_gen_op], [window_op]) graph.connect([window_op], [log_op]) graph.execute(FLAGS.framework)