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):
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)
# 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)
# 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, 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):
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, conf):
KwiverProcess.__init__(self, conf)
# declare our configuration items
self.declare_configuration_key('output', 'output-homog.txt',
'The output file name.')
required = kwiver.sprokit.pipeline.process.PortFlags()
required.add(self.flag_required)
# create input ports
self.add_port_trait('homography', 'homography_src_to_ref',
'Input homographies')
self.declare_input_port_using_trait('homography', required)
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 __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):
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 __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("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 __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):
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)