def __init__(self, conf): KwiverProcess.__init__(self, conf) # register python config file self.add_config_trait( 'config_file', 'config_file', '', 'Path to the json configuration file for the descriptor index to fetch from.' ) self.declare_config_using_trait('config_file') self.add_config_trait( 'video_name', 'video_name', '', 'Video name' ) self.declare_config_using_trait('video_name') self.add_config_trait( 'conn_str', 'conn_str', '', 'Connection string' ) self.declare_config_using_trait('conn_str') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) self.declare_input_port_using_trait('object_track_set', required) self.declare_output_port_using_trait('object_track_set', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) # register python config file self.add_config_trait( 'config_file', 'config_file', '', 'Path to the json configuration file for the descriptor index to add to.' ) self.declare_config_using_trait('config_file') self.add_config_trait( 'max_frame_buffer', 'max_frame_buffer', '0', 'Maximum number of frames to buffer descriptors over for larger batch sizes' ) self.declare_config_using_trait('max_frame_buffer') self.add_config_trait( 'max_descriptor_buffer', 'max_descriptor_buffer', '10000', 'Maximum number of descriptors to buffer over to make larger batch sizes' ) self.declare_config_using_trait('max_descriptor_buffer') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait('descriptor_set', required) self.declare_input_port_using_trait('string_vector', required) self.declare_output_port_using_trait('descriptor_set', optional) self.declare_output_port_using_trait('string_vector', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) self.__declare_config_traits() self._track_flag = False # AFRL start id : 0 # MOT start id : 1 self._step_id = 0 # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # input port ( port-name,flags) # self.declare_input_port_using_trait('framestamp', optional) self.declare_input_port_using_trait('image', required) self.declare_input_port_using_trait('detected_object_set', required) self.declare_input_port_using_trait('timestamp', required) self.declare_input_port_using_trait('object_track_set', optional) # output port ( port-name,flags) self.declare_output_port_using_trait('object_track_set', optional) self.declare_output_port_using_trait('detected_object_set', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) # Config file self.add_config_trait( "weights_file", "weights_file", 'models/mdnet_seed.pth', 'MDNet initial weight file for each object track.') self.declare_config_using_trait("weights_file") self.add_config_trait( "init_method", "init_method", 'external_only', 'Method for initializing new tracks, can be: external_only or ' 'using_detections.') self.declare_config_using_trait("init_method") self.add_config_trait( "init_threshold", "init_threshold", '0.20', 'If tracking multiple targets, the initialization threshold over ' 'detected object classifications for new tracks') self.declare_config_using_trait("init_threshold") self.add_config_trait( "iou_threshold", "iou_threshold", '0.50', 'If tracking multiple targets, the initialization threshold over ' 'box intersections in order to generate new tracks') self.declare_config_using_trait("iou_threshold") self.add_config_trait( "type_string", "type_string", '', 'If non-empty set the output track to be a track of this ' 'object category.') self.declare_config_using_trait("type_string") # add non-standard input and output elements self.add_port_trait("initializations", "object_track_set", "Input external track initializations") self.add_port_trait("recommendations", "object_track_set", "Input external track recommendations") self.add_port_trait("evaluation_requests", "detected_object_set", "External detections to test if target") self.add_port_trait("evaluations", "detected_object_set", "Completed evaluations with scores") # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # input port (port-name,flags) self.declare_input_port_using_trait('image', required) self.declare_input_port_using_trait('timestamp', required) self.declare_input_port_using_trait('detected_object_set', optional) self.declare_input_port_using_trait('initializations', required) self.declare_input_port_using_trait('recommendations', optional) self.declare_input_port_using_trait('evaluation_requests', optional) # output port (port-name,flags) self.declare_output_port_using_trait('timestamp', optional) self.declare_output_port_using_trait('object_track_set', optional) self.declare_output_port_using_trait('evaluations', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our ports (port-name, flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('image', optional)
def __init__(self, config): KwiverProcess.__init__(self, config) add_declare_config(self, "min_iou", str(DEFAULT_MIN_IOU), "Minimum IOU to associate a detection to a track") optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) self.declare_input_port_using_trait('detected_object_set', required) self.declare_input_port_using_trait('timestamp', required) self.declare_input_port_using_trait('homography_src_to_ref', required) self.declare_output_port_using_trait('object_track_set', optional)
def test_peek_at_datum_on_port(): """ Test peek at datum on a test port with complete datum """ from kwiver.sprokit.pipeline import process from kwiver.sprokit.pipeline import datum, DatumType from kwiver.vital.config import config from kwiver.sprokit.pipeline import edge from kwiver.sprokit.pipeline import stamp cfg = config.empty_config() # Create Dummy Receiver process receiver_proc = process.PythonProcess(cfg) optional = process.PortFlags() receiver_proc.declare_input_port("test_port", "test", optional, "test_port") # Create an Edge and connect input port to the edge test_edge = edge.Edge() receiver_proc.connect_input_port("test_port", test_edge) # Create an Edge Datum and push it to the port s = stamp.new_stamp(1) e_datum = edge.EdgeDatum(datum.complete(), s) test_edge.push_datum(e_datum) receiver_datum_type = receiver_proc.peek_at_datum_on_port( "test_port").type() if receiver_datum_type != DatumType.complete: test_error("Datum mismatch: expected a complete datum, got {0}".format( receiver_datum_type))
def __init__(self, conf): logger.debug(' ----- ' + self.__class__.__name__ + ' init') KwiverProcess.__init__(self, conf) camtrawl_setup_config(self, ctalgo.StereoLengthMeasurments.default_params()) self.add_config_trait('measurement_file', 'measurement_file', '', 'output file to write detection measurements') self.declare_config_using_trait('measurement_file') self.add_config_trait('calibration_file', 'calibration_file', 'cal_201608.mat', 'matlab or npz file with calibration info') self.declare_config_using_trait('calibration_file') required = process.PortFlags() required.add(self.flag_required) self.add_port_trait('detected_object_set1', 'detected_object_set', 'Detections from camera1') self.add_port_trait('detected_object_set2', 'detected_object_set', 'Detections from camera2') # declare our input ports ( port-name,flags ) self.declare_input_port_using_trait('detected_object_set1', required) self.declare_input_port_using_trait('detected_object_set2', required) # declare our output ports ( port-name,flags ) self.declare_output_port_using_trait('detected_object_set1', required) self.declare_output_port_using_trait('detected_object_set2', required)
def __init__(self, conf): KwiverProcess.__init__(self, conf) # set up configs self.add_config_trait("good_match_percent", "good_match_percent", '0.15', 'Good match percent [0.0,1.0].') self.add_config_trait("ratio_test", "ratio_test", '0.85', 'Feature point test ratio') self.add_config_trait("match_height", "match_height", '512', 'Match height.') self.add_config_trait("min_matches", "min_matches", '4', 'Minimum number of feature matches') self.add_config_trait("min_inliers", "min_inliers", '4', 'Minimum number of inliers') self.declare_config_using_trait('good_match_percent') self.declare_config_using_trait('ratio_test') self.declare_config_using_trait('match_height') self.declare_config_using_trait('min_matches') self.declare_config_using_trait('min_inliers') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our ports (port-name, flags) self.add_port_trait("optical_image", "image", "Input image") self.add_port_trait("thermal_image", "image", "Input image") self.add_port_trait("warped_optical_image", "image", "Output image") self.add_port_trait("warped_thermal_image", "image", "Output image") self.add_port_trait("optical_to_thermal_homog", "homography", "Output homog") self.add_port_trait("thermal_to_optical_homog", "homography", "Output homog") self.declare_input_port_using_trait('optical_image', required) self.declare_input_port_using_trait('thermal_image', required) self.declare_output_port_using_trait('warped_optical_image', optional) self.declare_output_port_using_trait('warped_thermal_image', optional) self.declare_output_port_using_trait('optical_to_thermal_homog', optional) self.declare_output_port_using_trait('thermal_to_optical_homog', optional)
def __init__(self, conf): print('conf = {!r}'.format(conf)) logger.debug(' ----- init ' + self.__class__.__name__) KwiverProcess.__init__(self, conf) camtrawl_setup_config( self, ctalgo.GMMForegroundObjectDetector.default_params()) # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('detected_object_set', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) self.add_config_trait("text", "text", 'Hello World', 'Text to display to user.') self.declare_config_using_trait('text') self.add_port_trait('out_image', 'image', 'Processed image') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('out_image', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) # GPU list self.add_config_trait("gpu_list", "gpu_list", 'all', gpu_list_desc(use_for='Resnet descriptors')) self.declare_config_using_trait('gpu_list') # Resnet #---------------------------------------------------------------------------------- self.add_config_trait("resnet_model_path", "resnet_model_path", 'models/resnet50_default.pt', 'Trained PyTorch model.') self.declare_config_using_trait('resnet_model_path') self.add_config_trait("resnet_model_input_size", "resnet_model_input_size", '224', 'Model input image size') self.declare_config_using_trait('resnet_model_input_size') self.add_config_trait("resnet_batch_size", "resnet_batch_size", '128', 'resnet model processing batch size') self.declare_config_using_trait('resnet_batch_size') #---------------------------------------------------------------------------------- # detection select threshold self.add_config_trait("detection_select_threshold", "detection_select_threshold", '0.0', 'detection select threshold') self.declare_config_using_trait('detection_select_threshold') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # input port ( port-name,flags) # self.declare_input_port_using_trait('framestamp', optional) self.declare_input_port_using_trait('image', required) self.declare_input_port_using_trait('detected_object_set', required) self.declare_input_port_using_trait('timestamp', required) # output port ( port-name,flags) self.declare_output_port_using_trait('detected_object_set', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) self.add_config_trait("output", "output", '.', 'The path of the file to output to.') self.declare_config_using_trait('output') self.add_port_trait('out_image', 'image', 'Processed image') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('out_image', optional)
def __init__(self, config): KwiverProcess.__init__(self, config) self.add_config_trait("pause_time", "pause_time", "1", "Time between pauses(in ms)") self.declare_config_using_trait("pause_time") self.add_config_trait("title", "title", "Test", "Title of the window") self.declare_config_using_trait("title") optional = process.PortFlags() self.declare_input_port_using_trait("image", optional)
def __init__(self, conf): process.PythonProcess.__init__(self, conf) self.declare_configuration_key('output', '', 'The path of the file to output to.') flags = process.PortFlags() flags.add(self.flag_required) self.declare_input_port('input', 'integer', flags, 'Where numbers are read from.')
def test_create(): from kwiver.sprokit.pipeline import datum from kwiver.sprokit.pipeline import process process.ProcessTypes() process.ProcessNames() process.ProcessProperties() process.PortFrequency(1) process.PortFrequency(1, 1) process.Ports() process.PortFlags() process.PortAddr() process.PortAddrs() process.Connection() process.Connections() process.PortInfo('type', process.PortFlags(), 'desc', process.PortFrequency(1, 1)) process.ConfInfo('default', 'desc', False) process.DataInfo(True, datum.DatumType.invalid) process.DataCheck.none process.DataCheck.sync process.DataCheck.valid
def __init__( self, conf ): KwiverProcess.__init__( self, conf ) # set up configs self.add_config_trait( "reference_image", "reference_image", '', 'Reference noise image' ) self.add_config_trait( "response_kernel", "response_kernel", '25', 'Response kernel size.' ) self.add_config_trait( "smooth_kernel", "smooth_kernel", '50', 'Local average kernel size' ) self.declare_config_using_trait( 'reference_image' ) self.declare_config_using_trait( 'response_kernel' ) self.declare_config_using_trait( 'smooth_kernel' ) # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add( self.flag_required ) # declare our ports (port-name, flags) self.declare_input_port_using_trait( 'image', required ) self.declare_output_port_using_trait( 'image', optional )
def __init__(self, conf): process.PythonProcess.__init__(self, conf) self.stepped = False self.finalized = False self.conf_output = 'output' self.declare_configuration_key(self.conf_output, 'output.txt', 'Output file name', False) self.port_input = 'number' required = process.PortFlags() required.add(self.flag_required) self.declare_input_port(self.port_input, 'integer', required, 'input port')
def __init__(self, conf): process.PythonProcess.__init__(self, conf) self.conf_start = 'start' self.conf_end = 'end' self.declare_configuration_key(self.conf_start, str(0), 'Starting number', False) self.declare_configuration_key(self.conf_end, str(10), 'Ending number', True) self.port_output = 'number' required = process.PortFlags() required.add(self.flag_required) self.declare_output_port(self.port_output, 'integer', required, 'output port')
def __init__(self, conf): KwiverProcess.__init__(self, conf) # Add trait for our output port self.add_port_trait( 'vector', 'double_vector', 'Output descriptor vector' ) # set up required flags required = process.PortFlags() required.add(self.flag_required) # declare our ports ( port-name, flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('vector', required ) # declare our configuration self.declare_configuration_key( "config_file", "", "Descriptor configuration file name" )
def test_api_calls(): from kwiver.sprokit.pipeline import datum from kwiver.sprokit.pipeline import process a = process.PortAddr() a.process a.port a.process = '' a.port = '' f = process.PortFrequency(1, 1) a = process.PortInfo('type', process.PortFlags(), 'desc', f) a.type a.flags a.description a.frequency a = process.ConfInfo('default', 'desc', False) a.default a.description a.tunable a = process.DataInfo(True, datum.DatumType.invalid) a.in_sync a.max_status process.PythonProcess.property_no_threads process.PythonProcess.property_no_reentrancy process.PythonProcess.property_unsync_input process.PythonProcess.property_unsync_output process.PythonProcess.port_heartbeat process.PythonProcess.config_name process.PythonProcess.config_type process.PythonProcess.type_any process.PythonProcess.type_none process.PythonProcess.type_data_dependent process.PythonProcess.type_flow_dependent process.PythonProcess.flag_output_const process.PythonProcess.flag_output_shared process.PythonProcess.flag_input_static process.PythonProcess.flag_input_mutable process.PythonProcess.flag_input_nodep process.PythonProcess.flag_required
def __init__(self, config): KwiverProcess.__init__(self, config) self.add_config_trait("bbox_width", "bbox_width", "30", "Width of bbox") self.declare_config_using_trait("bbox_width") self.add_config_trait("bbox_height", "bbox_height", "30", "Height of bbox") self.declare_config_using_trait("bbox_height") optional = process.PortFlags() self.declare_input_port_using_trait("image", optional) self.declare_input_port_using_trait("timestamp", optional) self.declare_input_port_using_trait("file_name", optional) self.declare_output_port_using_trait("detected_object_set", optional)
def test_flags_as_set(): from kwiver.sprokit.pipeline import process # TODO: Make tests more rigorous (check more than just len()). a = process.PortFlags() # adding to the set a.add(process.PythonProcess.flag_required) a.add(process.PythonProcess.flag_input_mutable) a.add(process.PythonProcess.flag_input_nodep) a.add(process.PythonProcess.flag_input_static) # length if not len(a) == 4: test_error("len() does not work: expected 4, got %d" % len(a)) # adding duplicate values a.add(process.PythonProcess.flag_required) if not len(a) == 4: test_error(".add() added a duplicate item: expected 4, got %d" % len(a)) # adding invalid objects expect_exception('adding a value of an invalid type', TypeError, process.PortFlags.add, a, True), # 'in' keyword if process.PythonProcess.flag_required not in a: test_error("a value in the set is 'not in' the set") if process.PythonProcess.flag_output_const in a: test_error("a value not in the set is 'in' the set") # iteration for value in a: pass # boolean casting if not a: test_error("a non-empty set is False-like") b = process.PortFlags() if b: test_error("an empty set is True-like") # removal expect_exception('.pop() on an empty set', KeyError, process.PortFlags.pop, b) expect_exception('.remove() with an item that does not exist in the set', KeyError, process.PortFlags.remove, a, process.PythonProcess.flag_output_const) a.discard(process.PythonProcess.flag_output_const) if not len(a) == 4: test_error(".discard() removed an item not in the set") a.discard(process.PythonProcess.flag_input_static) if not len(a) == 3: test_error(".discard() did not remove an item from the set") a.remove(process.PythonProcess.flag_input_nodep) if not len(a) == 2: test_error(".remove() did not remove an item from the set") a.pop() if not len(a) == 1: test_error(".pop() did not remove an item from the set") a.clear() if a: test_error(".clear() did not make a False-like set") # copy b.add(process.PythonProcess.flag_required) c = b.copy() b.clear() if not c: test_error(".clear() on a set modified a set created using .copy()") c = b.copy() b.add(process.PythonProcess.flag_required) if c: test_error(".add() on a set modified a set created using .copy()") # set vs. set queries a.add(process.PythonProcess.flag_input_nodep) a.add(process.PythonProcess.flag_input_static) if not b.isdisjoint(a): test_error(".isdisjoint() does not work") if b.issubset(a): test_error(".issubset() does not work") if a.issuperset(b): test_error(".issuperset() does not work") a.add(process.PythonProcess.flag_required) if b.isdisjoint(a): test_error(".isdisjoint() does not work") if not b.issubset(a): test_error(".issubset() does not work") if not a.issuperset(b): test_error(".issuperset() does not work") u = a.union(b) if not len(u) == 3: test_error(".union() does not work: expected 3, got %d" % len(u)) d = a.difference(b) if not len(d) == 2: test_error(".difference() does not work: expected 2, got %d" % len(d)) i = a.intersection(b) if not len(i) == 1: test_error(".intersection() does not work: expected 1, got %d" % len(i)) b.add(process.PythonProcess.flag_output_const) s = a.symmetric_difference(b) if not len(s) == 3: test_error( ".symmetric_difference() does not work: expected 3, got %d" % len(s)) a.update(b) if not len(a) == 4: test_error(".update() does not work: expected 4, got %d" % len(a))
def __init__(self, conf): KwiverProcess.__init__(self, conf) # register port and config traits self.add_port_traits() self.add_config_traits() # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) ## declare our input port ( port-name,flags) # user-provided positive examplar descriptors. self.declare_input_port_using_trait('positive_descriptor_set', required) self.declare_input_port_using_trait('positive_exemplar_uids', required) # user-provided negative examplar descriptors. self.declare_input_port_using_trait('negative_descriptor_set', optional) self.declare_input_port_using_trait('negative_exemplar_uids', optional) # user adjudicated positive and negative descriptor UUIDs self.declare_input_port_using_trait('iqr_positive_uids', optional) self.declare_input_port_using_trait('iqr_negative_uids', optional) # input model if pre-generated self.declare_input_port_using_trait('iqr_query_model', optional) # Output, ranked descriptor UUIDs self.declare_output_port_using_trait('result_uids', optional) # Output, feedback descriptor UUIDs in decreasing order of # importance self.declare_output_port_using_trait('feedback_uids', optional) # Output, ranked descriptor scores. self.declare_output_port_using_trait('result_scores', optional) # Output, distances of feedback descriptors from the separating plane # in increasing order of magnitude. These distances correspond to # feedback_uids. self.declare_output_port_using_trait('feedback_distances', optional) # Output, feedback scores corresponding to the descriptors. self.declare_output_port_using_trait('feedback_scores', optional) # Output, trained IQR model. self.declare_output_port_using_trait('result_model', optional) ## Member variables to be configured in ``_configure``. # Path to the json config file for the DescriptorIndex self.di_json_config_path = None self.di_json_config = None # Path to the json config file for the NearestNeighborsIndex self.nn_json_config_path = None self.nn_json_config = None # Number of top, refined descriptor UUIDs to return per step. self.query_return_n = None # Set of descriptors to pull positive/negative querys from. self.descriptor_set = None # Nearest Neighbors index to use for IQR working index population. self.neighbor_index = None # IQR session state object self.iqr_session = None # Factory for converting vital descriptors to smqtk. Currently just # use in-memory elements for conversion. self.smqtk_descriptor_element_factory = smqtk.representation.DescriptorElementFactory( smqtk.representation.descriptor_element.local_elements. DescriptorMemoryElement, {})
def __init__(self, conf): KwiverProcess.__init__(self, conf) # GPU list #---------------------------------------------------------------------------------- self.add_config_trait("gpu_list", "gpu_list", 'all', gpu_list_desc(use_for='augmentation')) self.declare_config_using_trait('gpu_list') # Resnet #---------------------------------------------------------------------------------- self.add_config_trait("resnet_model_path", "resnet_model_path", 'resnet/snapshot_epoch_6.pt', 'Trained PyTorch model.') self.declare_config_using_trait('resnet_model_path') self.add_config_trait("resnet_model_input_size", "resnet_model_input_size", '224', 'Model input image size') self.declare_config_using_trait('resnet_model_input_size') self.add_config_trait("resnet_batch_size", "resnet_batch_size", '2', 'resnet model processing batch size') self.declare_config_using_trait('resnet_batch_size') #---------------------------------------------------------------------------------- # detection select threshold self.add_config_trait("detection_select_threshold", "detection_select_threshold", '0.0', 'detection select threshold') self.declare_config_using_trait('detection_select_threshold') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) #---------------------------------------------------------------------------------- self.add_config_trait("use_historical_database", "use_historical_database", 'false', 'Historical database for negative exemplars') self.declare_config_using_trait('use_historical_database') self.add_config_trait("historical_tree", "historical_tree", 'historical_tree.kdtree.pickle', 'Historical database for negative exemplars') self.declare_config_using_trait('historical_tree') self.add_config_trait("historical_database", "historical_database", 'historical_descriptors.kdtree.pickle', 'Historical database for negative exemplars') self.declare_config_using_trait('historical_database') self.add_config_trait( "negative_sample_count", "negative_sample_count", '1000', 'Number of negative samples to use from the database') self.declare_config_using_trait('negative_sample_count') self.add_config_trait("rotational_shifts", "rotational_shifts", '36', 'Augmentation rotational shifts') self.declare_config_using_trait('rotational_shifts') self.add_config_trait("resize_factor", "resize_factor", '0.2', 'Augmentation scale shift factor') self.declare_config_using_trait('resize_factor') self.add_config_trait("int_shift_factor", "int_shift_factor", '0.2', 'Augmentation intensity shift factor') self.declare_config_using_trait('int_shift_factor') # Custom port IDs #---------------------------------------------------------------------------------- self.add_port_trait("new_positive_descriptors", "descriptor_set", "Positive exemplar descriptor set") self.add_port_trait("new_positive_ids", "string_vector", "Positive exemplar descriptor UUIDs") self.add_port_trait("new_negative_descriptors", "descriptor_set", "Negative exemplar descriptor set") self.add_port_trait("new_negative_ids", "string_vector", "Negative exemplar descriptor UUIDs") # input port ( port-name,flags) # self.declare_input_port_using_trait('framestamp', optional) self.declare_input_port_using_trait('image', required) self.declare_input_port_using_trait('detected_object_set', required) # output port ( port-name,flags) self.declare_output_port_using_trait('new_positive_descriptors', optional) self.declare_output_port_using_trait('new_positive_ids', optional) self.declare_output_port_using_trait('new_negative_descriptors', optional) self.declare_output_port_using_trait('new_negative_ids', optional)