repo/traffic-intelligence: python/moving.py comparison

comparison python/moving.py @ 594:9e39cd95e017

first implementation of CLEAR MOT (needs formal tests)

author	Nicolas Saunier <nicolas.saunier@polymtl.ca>
date	Sun, 07 Dec 2014 01:32:36 -0500
parents	e2a873e08568
children	17b02c8054d0

comparison

equal deleted inserted replaced

-:e2a873e08568
+:9e39cd95e017
 if homography != None:
 self.positions = self.positions.project(homography)
 def matches(self, obj, instant, matchingDistance):
 '''Indicates if the annotation matches obj (MovingObject)
-with threshold matchingDistance'''
+with threshold matchingDistance
+Returns distance if below matchingDistance, matchingDistance+1 otherwise
+(returns an actual value, otherwise munkres does not terminate)'''
 d = Point.distanceNorm2(self.getPositionAtInstant(instant), obj.getPositionAtInstant(instant))
-return d<matchingDistance, d
+if d < matchingDistance:
+return d
-def matchingGroundTruthToTracker(objects, annotations, matchingDistance, firstInstant, lastInstant):
+else:
-'''Returns a matching of tracker output (objects) to ground truth (annnotations)
+return matchingDistance + 1
+def computeClearMOT(objects, annotations, matchingDistance, firstInstant, lastInstant, debug = False):
+'''Computes the CLEAR MOT metrics
+Reference:
+Keni, Bernardin, and Stiefelhagen Rainer. "Evaluating multiple object tracking performance: the CLEAR MOT metrics." EURASIP Journal on Image and Video Processing 2008 (2008)
 objects and annotations are supposed to in the same space
 current implementation is BBAnnotations (bounding boxes)
 mathingDistance is threshold on matching between annotation and object
-Output is list of
+TO: tracker output (objects)
-[frame number, ground truth id, tracker object id, distance]
+GT: ground truth (annotations)
-where tracker object id is None if no matching was found'''
+Should we use the distance as weights or just 1/0 if distance below matchingDistance?
-matchTable = []
+(add argument useDistanceForWeights = False)'''
+from munkres import Munkres
+from numpy import array
+from sys import maxsize
+munk = Munkres()
+dist = 0. # total distance between GT and TO
+ct = 0 # number of associations between GT and tracker output in each frame
+gt = 0 # number of GT.frames
+mt = 0 # number of missed GT.frames (sum of the number of GT not detected in each frame)
+fpt = 0 # number of false alarm.frames (tracker objects without match in each frame)
+mme = 0 # number of mismatches
+matches = {} # match[i] is the tracker track associated with GT i (using object references)
 for t in xrange(firstInstant, lastInstant+1):
-for a in annotations:
+previousMatches = matches.copy()
-if a.existsAtInstant(t):
+# go through currently matched GT-TO and check if they are still matched withing matchingDistance
-minDist = float('inf')
+toDelete = []
-matchingObject = None
+for a in matches:
-for o in objects:
+if a.existsAtInstant(t) and matches[a].existsAtInstant(t):
-if o.existsAtInstant(t):
+d = a.matches(matches[a], t, matchingDistance)
-match, d = a.matches(o, t, matchingDistance)
+if d < matchingDistance:
-if match and d<minDist:
+dist += d
-minDist = d
-matchingObject = o
-if matchingObject == None:
-matchTable.append([t, a.getNum(), None, minDist])
 else:
-matchTable.append([t, a.getNum(), matchingObject.getNum(), minDist])
+toDelete.append(a)
-return matchTable
+else:
+toDelete.append(a)
-def computeClearMOT(matchTable, nTrackFrames):
+for a in toDelete:
-'''Computes the MOTA/MOTP measures from the matching statistics
+del matches[a]
-between ground truth and tracker output
-computed by matchingGroundTruthToTracker
+# match all unmatched GT-TO
+matchedGTs = matches.keys()
-nTrackFrames is the sum of the number of frames of existence of all tracker output
+matchedTOs = matches.values()
+costs = []
-Adapted from Dariush Ettehadieh's thesis work'''
+unmatchedGTs = [a for a in annotations if a.existsAtInstant(t) and a not in matchedGTs]
-#Calculate MOTP
+unmatchedTOs = [o for o in objects if o.existsAtInstant(t) and o not in matchedTOs]
-dist = 0. # total distance between GT and tracker output
+nGTs = len(matchedGTs)+len(unmatchedGTs)
-nAssociatedGTFrames = 0
+nTOs = len(matchedTOs)+len(unmatchedTOs)
-mt = 0 # number of missed GT frames (sum of the number of GT not detected in each frame)
+if len(unmatchedTOs) > 0:
-for mtab in matchTable:
+for a in unmatchedGTs:
-if mtab[2] != None:
+aCosts = [a.matches(o, t, matchingDistance) for o in unmatchedTOs]
-dist += float(mtab[3])#/T
+if min(aCosts) < matchingDistance:
-nAssociatedGTFrames += 1
+costs.append(aCosts)
-else:
+# print costs
-mt += 1
+if len(costs) > 0:
-if nAssociatedGTFrames != 0:
+newMatches = munk.compute(costs)
-motp = dist/nAssociatedGTFrames
+for k,v in newMatches:
+if costs[k][v] < matchingDistance:
+matches[unmatchedGTs[k]]=unmatchedTOs[v]
+dist += costs[k][v]
+if debug:
+print('{} '.format(t)+', '.join(['{} {}'.format(k.getNum(), v.getNum()) for k,v in matches.iteritems()]))
+# compute metrics elements
+ct += len(matches)
+mt += nGTs-len(matches)
+fpt += nTOs-len(matches)
+gt += nGTs
+# compute mismatches
+# for gt that do not appear in both frames, check if the corresponding to was matched to another gt in previous/next frame
+mismatches = []
+for a in matches:
+if a in previousMatches:
+if matches[a] != previousMatches[a]:
+mismatches.append(a)
+elif matches[a] in previousMatches.values():
+mismatches.append(matches[a])
+for a in previousMatches:
+if a not in matches and previousMatches[a] in matches.values():
+mismatches.append(previousMatches[a])
+if debug:
+for mm in set(mismatches):
+print type(mm), mm.getNum()
+# some object mismatches may appear twice
+mme += len(set(mismatches))
+if ct > 0:
+motp = dist/ct
 else:
-return 0,0,0,0,0,0
+motp = None
+return motp, 1.-float(mt+fpt+mme)/gt, mt, mme, fpt, gt
-#Calculate MOTA
-gt = len(matchTable) # sum of the number of GT in each frame, or sum of the length of existence of each GT
-#for sgt in sorted_gt_positions:
-#    gt += (len(sgt)-1)
-#total_traces = len(object_positions)
-fpt = nTrackFrames - nAssociatedGTFrames
-# gtobj = 0
-mme = 0
-# while gtobj <= n_gt_objects:
-#     prev = [0,0,-1,0]
-#     new_match = 0
-#     for mtab in matchTable:
-#         if mtab[1] == gtobj:
-#             if new_match == 0:
-#                 new_match = 1
-#                 mme = mme - 1
-#                 if mtab[2] != prev[2]:
-#                     mme += 1
-#                     prev = mtab
-#                     gtobj += 1
-mota = 1-(float(mt+fpt+mme)/gt)
-print 'MOTP: ' + str(motp)
-print 'MOTA: ' + str(mota)
-return motp, mota, dist, mt, mme, fpt
 def plotRoadUsers(objects, colors):
 '''Colors is a PlottingPropertyValues instance'''
 from matplotlib.pyplot import figure, axis

Mercurial Hosting > traffic-intelligence

comparison python/moving.py @ 594:9e39cd95e017