def start(self):
self.dset_store.clear()
for m in self.modules:
m.reset()
start_timestamp = ds.TimeStamp(config.FRAME_START, config.CAM)
duration = config.FRAME_END - config.FRAME_START + 1
previous_timestamp = start_timestamp
for x in range(config.FRAME_START + 1, config.FRAME_END + 1):
timestamp = ds.TimeStamp(x, config.CAM)
timestamp.connect_with_previous(previous_timestamp)
previous_timestamp = timestamp
print 'start validation'
print(' date = ' + str(config.DATE[0]) + '/' + str(config.DATE[1]) +
'/' + str(config.DATE[2]) + ', ' + 'time = ' +
str(config.TIME[0]) + ':' + str(config.TIME[1]))
print ' cam = ' + str(config.CAM) + ', frames = ' + str(
config.FRAME_START) + ' til ' + str(config.FRAME_END)
database_connection = db.Connection()
timestamp = start_timestamp
for x in range(0, duration):
print 'processing timestamp ' + timestamp.time_name
dset = self.dset_store.get(timestamp, database_connection)
for d in dset.detections:
updated_id = database_connection.get_updated_id(d)
truth_id = database_connection.get_truth_id(d)
path_number = database_connection.get_path_number(d)
for m in self.modules:
m.update(d, updated_id, truth_id, path_number)
timestamp = timestamp.get_next()
if timestamp is None:
break
print 'validation finished'
print '--------------------------------'
result_text = ''
for m in self.modules:
result_text += m.get_result()
print result_text
def start(self):
self.path_manager.clear()
self.dset_store.clear()
start_timestamp = ds.TimeStamp(config.FRAME_START, config.CAM)
duration = config.FRAME_END - config.FRAME_START + 1
previous_timestamp = start_timestamp
for x in range(config.FRAME_START + 1, config.FRAME_END + 1):
timestamp = ds.TimeStamp(x, config.CAM)
timestamp.connect_with_previous(previous_timestamp)
previous_timestamp = timestamp
print 'start filtering'
print(' date = ' + str(config.DATE[0]) + '/' + str(config.DATE[1]) +
'/' + str(config.DATE[2]) + ', ' + 'time = ' +
str(config.TIME[0]) + ':' + str(config.TIME[1]))
print ' cam = ' + str(config.CAM) + ', frames = ' + str(
config.FRAME_START) + ' til ' + str(config.FRAME_END)
database_connection = db.Connection()
timestamp = start_timestamp
# computing
for x in range(0, duration):
print 'processing timestamp ' + timestamp.time_name
self.process_timestamp(timestamp, database_connection)
print(' paths: ' + str(len(self.path_manager.open_paths)) +
' open, ' + str(len(self.path_manager.closed_paths)) +
' closed')
timestamp = timestamp.get_next()
if timestamp is None:
break
print 'filtering finished'
# saving
self.path_manager.close_all_paths()
self.path_manager.save_closed_paths(database_connection)
print str(len(self.path_manager.closed_paths)
) + ' paths saved to file ' + config.PATHS_FILE
print '--------------------------------'
def start( self ):
self.dset_store.clear()
self.path_manager.clear()
start_timestamp = ds.TimeStamp( config.FRAME_START, config.CAM )
duration = config.FRAME_END - config.FRAME_START + 1
previous_timestamp = start_timestamp
for x in range( config.FRAME_START+1, config.FRAME_END+1 ):
timestamp = ds.TimeStamp( x, config.CAM )
timestamp.connect_with_previous( previous_timestamp )
previous_timestamp = timestamp
print 'start generation'
print (
' date = ' + str( config.DATE[ 0 ] ) + '/' + str( config.DATE[ 1 ] ) + '/' + str( config.DATE[ 2 ] ) + ', '
+ 'time = ' + str( config.TIME[ 0 ] ) + ':' + str( config.TIME[ 1 ] )
)
print ' cam = ' + str( config.CAM ) + ', frames = ' + str( config.FRAME_START ) + ' til ' + str( config.FRAME_END )
database_connection = db.Connection()
timestamp = start_timestamp
hammings = np.zeros( 13, dtype = np.int ) # nach Hammingabstand 0-12
gaps = {}
for x in range( 0, duration ):
print 'processing timestamp ' + timestamp.time_name
dset = self.dset_store.get( timestamp, database_connection )
for d in dset.detections:
truth_id = database_connection.get_truth_id( d )
if truth_id is not None:
hamming_dis = aux.hamming_distance( truth_id, d.decoded_mean )
hammings[ hamming_dis ] += 1
path = self.path_manager.get_path( truth_id )
gap = path.add_detection_and_return_gap( d )
if gap is not None:
gap = min(gap,16) # greater or equal 16 not listed separately
if not gap in gaps:
gaps[ gap ] = 0
gaps[ gap ] += 1
timestamp = timestamp.get_next()
if timestamp is None:
break
print 'generation finished'
print '--------------------------------'
detection_count = sum( hammings )
hammings_percentage = hammings*1.0 / detection_count
print 'validation finished'
print '\nhammings result:'
print np.round( hammings_percentage*100, 1 )
print '\ndetection count:'
print detection_count
print '\ngaps:'
print [ g for g in sorted( gaps.items() ) ]
print 'mean gap length: ' + str(sum([ l*n for l,n in gaps.items() ])*1.0/sum([ n for l,n in gaps.items() ]))
print 'gaps count: ' + str( sum([ n for l,n in gaps.items() ] ) )
def load_data( self ): self.load_button.setDisabled( True ) self.goto_editor_button.setDisabled( True ) self.app.processEvents() start_timestamp = ds.TimeStamp( self.date_input.date(), self.start_time_input.time(), self.cam_input.value() ) end_timestamp = ds.TimeStamp( self.date_input.date(), self.end_time_input.time(), self.cam_input.value() ) if start_timestamp < end_timestamp and start_timestamp.exists(): dset_store = self.parent.dset_store dset_store.clear() path_manager = self.parent.path_manager path_manager.clear() if self.load_source_truth.isChecked(): path_manager.data_source = 0 # truth_id else: path_manager.data_source = 1 # updated_id diff = start_timestamp.frames_difference( end_timestamp ) self.load_progress.setMaximum( diff+1 ) self.app.processEvents() database_connection = db.Connection() loop_timestamp = start_timestamp loop_index = 0 while ( loop_timestamp is not None ) and ( not end_timestamp < loop_timestamp ): dset = dset_store.get( loop_timestamp, database_connection ) for d in dset.detections: if path_manager.data_source == 0: truth_id = database_connection.get_truth_id( d ) if truth_id is not None: path_manager.add_detection( d, truth_id ) else: updated_id = database_connection.get_updated_id( d ) if updated_id is not None: path_number = database_connection.get_path_number( d ) if path_number is not None: path_manager.add_detection_to_path( d, updated_id, path_number ) else: path_manager.add_detection( d, updated_id ) loop_timestamp = loop_timestamp.get_next( database_connection ) loop_index += 1 self.load_progress.setValue( loop_index ) self.app.processEvents() database_connection.close() self.load_progress.setValue( diff+1 ) self.load_button.setDisabled( False ) self.goto_editor_button.setDisabled( False ) self.app.processEvents()
def load_data(self):
if not os.path.exists(config.DATA_FOLDER):
print 'Error: folder not found'
return
self.block_inputs(True)
self.dset_store = ds.DetectionSetStore()
self.path_manager = None
self.paths_load_progress.setValue(0)
self.paths_load_label.setText('')
try:
repo = Repository(config.DATA_FOLDER)
start_time = datetime(config.DATE[0],
config.DATE[1],
config.DATE[2],
config.TIME[0],
config.TIME[1],
tzinfo=pytz.utc)
fnames = repo.iter_fnames(begin=start_time)
for fname in fnames:
frame_container = load_frame_container(fname)
cam = frame_container.camId
#frame_container.fromTimestamp # already available
#frame_container.toTimestamp # already available
self.dset_store.source = frame_container.dataSources[
0].filename
previous_timestamp = None
self.data_load_progress.setMaximum(config.FRAME_END + 1 -
config.FRAME_START)
self.app.processEvents()
frame_index = config.FRAME_START
for frame in list(frame_container.frames
)[config.FRAME_START:config.FRAME_END + 1]:
#timestamp = frame.timestamp # not included yet
#frame.id # not included yet
timestamp = ds.TimeStamp(frame_index, cam)
timestamp.connect_with_previous(previous_timestamp)
previous_timestamp = timestamp
dset = ds.DetectionSet()
self.dset_store.store[timestamp] = dset
data = convert_frame_to_numpy(frame)
for detection_data in data:
dset.add_detection(
ds.Detection(
detection_data['idx'],
timestamp,
np.array(
[
detection_data['ypos'],
detection_data['xpos']
]
), # rotated, otherwise will be portrait orientation
detection_data['localizerSaliency'],
detection_data['decodedId']
[::
-1] # reversed, we want least significant bit last
))
frame_index += 1
self.data_load_progress.setValue(frame_index -
config.FRAME_START)
self.app.processEvents()
self.data_load_label.setText(
str(len(self.dset_store.store)) + ' frames loaded')
self.app.processEvents()
# break because we only load the first fname
break
except:
pass
self.block_inputs(False)
def start( self ): self.dset_store.clear() self.path_manager.clear() start_timestamp = ds.TimeStamp( config.FRAME_START, config.CAM ) duration = config.FRAME_END - config.FRAME_START + 1 previous_timestamp = start_timestamp for x in range( config.FRAME_START+1, config.FRAME_END+1 ): timestamp = ds.TimeStamp( x, config.CAM ) timestamp.connect_with_previous( previous_timestamp ) previous_timestamp = timestamp print 'start generation' print ( ' date = ' + str( config.DATE[ 0 ] ) + '/' + str( config.DATE[ 1 ] ) + '/' + str( config.DATE[ 2 ] ) + ', ' + 'time = ' + str( config.TIME[ 0 ] ) + ':' + str( config.TIME[ 1 ] ) ) print ' cam = ' + str( config.CAM ) + ', frames = ' + str( config.FRAME_START ) + ' til ' + str( config.FRAME_END ) database_connection = db.Connection() timestamp = start_timestamp for x in range( 0, duration ): print 'processing timestamp ' + timestamp.time_name dset = self.dset_store.get( timestamp, database_connection ) for d in dset.detections: truth_id = database_connection.get_truth_id( d ) if truth_id is not None: path = self.path_manager.get_path( truth_id ) path.add_detection( d ) timestamp = timestamp.get_next() if timestamp is None: break print 'calculate average ids...' total = 0 mean_rights = 0 mean_mean_rights = 0 weigneig_rights = 0 saliency_rights = 0 confidence_rights = 0 false_text = '' for truth_id, path in self.path_manager.paths.iteritems(): if len( path.detections ) >= 10: for iterations in range( 100 ): #path_sample = path subset_size = 20 path_sample = path.random_subset( subset_size ) total += 1 mean_id = path_sample.determine_average_id_by_mean() mean_mean_id = path_sample.determine_average_id_by_mean_mean() weigneig_id = path_sample.determine_average_id_by_weighted_neighbourhood() saliency_id = path_sample.determine_average_id_with_saliency() confidence_id = path_sample.determine_average_id_with_confidence() if mean_id == truth_id: mean_rights += 1 else: false_text += '\n----\n' + str( aux.int_id_to_binary( truth_id ) ) + ' (truth)' false_text += ' id=' + str(truth_id) + ' len=' + str( len( path_sample.detections ) ) false_text += '\n' + str( path_sample.ids_sum / path_sample.ids_count ) + ' (determined)' false_text += '\n' + str( aux.int_id_to_binary( mean_id ) ) + ' (determined rounded)' #for d in path_sample.detections.values(): # false_text += '\n' + str( aux.int_id_to_binary( d.decoded_mean ) ) if mean_mean_id == truth_id: mean_mean_rights += 1 if weigneig_id == truth_id: weigneig_rights += 1 if saliency_id == truth_id: saliency_rights += 1 #else: # false_text += '\n----\n' + str( aux.int_id_to_binary( truth_id ) ) + ' (truth)' # false_text += ' id=' + str(truth_id) + ' len=' + str( len( path_sample.detections ) ) # false_text += '\n' + str( path_sample.ids_sum_saliency / path_sample.saliency_count ) + ' (determined)' # false_text += '\n' + str( aux.int_id_to_binary( saliency_id ) ) + ' (determined rounded)' if confidence_id == truth_id: confidence_rights += 1 print 'validation finished' print '--------------------------------' result_text = 'Average ID Results:\n' result_text += 'of ' + str(total) + ' paths:\n' result_text += ( "%.3f" % (mean_rights*1.0/total )) + ' correct through determine_average_id_by_mean()\n' result_text += ( "%.3f" % (mean_mean_rights*1.0/total )) + ' correct through determine_average_id_by_mean_mean()\n' result_text += ( "%.3f" % (weigneig_rights*1.0/total )) + ' correct through determine_average_id_by_weighted_neighbourhood()\n' result_text += ( "%.3f" % (saliency_rights*1.0/total )) + ' correct through determine_average_id_with_saliency()\n\n' result_text += ( "%.3f" % (confidence_rights*1.0/total )) + ' correct through determine_average_id_with_confidence()\n\n' #result_text += false_text print result_text