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)
