python benchmark

butil/__init__.py

@@ -0,0 +1,24 @@
+import math
+
+from config import *
+from seq_config import *
+from eval_results import *
+from load_results import *
+from shift_bbox import *
+from split_seq import *
+from calc_seq_err_robust import *
+from calc_rect_center import *
+
+def d_to_f(x):
+    return map(lambda o:round(float(o),4), x)
+
+def matlab_double_to_py_float(double):
+    return map(d_to_f, double)
+
+def ssd(x, y):
+    if len(x) != len(y):
+        sys.exit("cannot calculate ssd")
+    s = 0
+    for i in range(len(x)):
+        s += (x[i] - y[i])**2
+    return math.sqrt(s)

butil/calc_rect_center.py

@@ -0,0 +1,145 @@
+import butil
+import math
+import numpy as np
+
+def corners2rect(corners):
+    result_corners = np.floor(corners[:,0:4])
+    x = result_corners[0,0]
+    y = result_corners[1,0]
+    w = result_corners[0,2] - x
+    h = result_corners[1,2] - y
+    rect = map(int, [x, y, w, h])
+    return rect
+
+def rect_affine_IVT(tmplsize, res):
+    w = float(tmplsize[0])
+    h = float(tmplsize[1])
+    corners = np.matrix((
+        (1,-w/2,-h/2),
+        (1,w/2,-h/2),
+        (1,w/2,h/2),
+        (1,-w/2,h/2),
+        (1,-w/2,-h/2))).T
+    p = res
+    M = np.matrix(((p[0], p[2], p[3]), (p[1], p[4], p[5])))
+    c = M * corners
+    rect = corners2rect(c)
+    return rect
+
+def rect_affine_L1(tmplsize, res):
+    w = float(tmplsize[0])
+    h = float(tmplsize[1])
+    corners = np.matrix((
+        (1,w,w,1),
+        (1,1,h,h),
+        (1,1,1,1)))
+    p = res
+    M = np.matrix(((p[2], p[3], p[5]), (p[0], p[1], p[4])))
+    c = M * corners
+    rect = corners2rect(c)
+    return rect
+
+def rect_affine_LK(tmplsize, res):
+    h = float(tmplsize[0])
+    w = float(tmplsize[1])
+    corners = np.matrix((
+        (1,1,1),
+        (1,h,1),
+        (w,h,1),
+        (w,1,1))).T
+    p = res
+    M = np.matrix(((p[0], p[1], p[4]), (p[2], p[3], p[5])))
+    c = M * corners
+    rect = corners2rect(c)
+    return rect
+
+def rect_4corners(res):
+    rect = corners2rect(res)
+    return rect
+
+def rect_similarity(tmplsize, res):
+    h = float(tmplsize[0])
+    w = float(tmplsize[1])
+
+    corners = np.matrix((
+        (1,w,w,1),
+        (1,1,h,h),
+        (1,1,1,1)))
+    p = res
+    s = np.matrix((
+            (math.cos(p[1]), -math.sin(p[1])),
+            (-math.sin(p[1]), math.cos(p[1]))))
+    s = p[0] * s
+    M = np.matrix((
+            (s[0,0], s[0,1], p[2]),
+            (s[1,0], s[1,1], p[3])))
+    c = M * corners
+    rect = corners2rect(c)
+    return rect
+
+
+def calc_rect_center(*params):
+    if (len(params) == 2):
+        tmplsize = params[0][0]
+        w = float(tmplsize[0])
+        h = float(tmplsize[1])
+        params = [params[1:][0]]
+    else:
+        w = float(params[0])
+        h = float(params[1])
+        params = [params[2:]]
+
+    if len(params) < 1 or len(params[0]) != 6:
+        M = np.matrix(((0,1,0), (0,0,1)))
+    else:
+        p = params[0]
+        M = np.matrix(((p[0], p[2], p[3]), (p[1], p[4], p[5])))
+    corners = np.matrix(((1,-w/2,-h/2),
+        (1,w/2,-h/2), (1,w/2,h/2), (1,-w/2,h/2), (1,-w/2,-h/2))).T
+
+    corners = M * corners;
+    result_corners = np.floor(corners[:,0:4])
+    x = result_corners[0,0]
+    y = result_corners[1,0]
+    w = result_corners[0,2] - x
+    h = result_corners[1,2] - y
+    rect = map(int, [x, y, w, h])
+    center = np.mean(corners[:,0:4],1)
+    return rect, center, corners
+
+def aff2image(aff_maps, T_sz):
+    r = T_sz[0]
+    c = T_sz[1]
+    n = aff_maps.shape[1]
+    boxes = np.zeros((8, n))
+    for i in range(n):
+        aff = aff_maps[:,i].A1
+        R = np.matrix((
+            (aff[0], aff[1], aff[4]),
+            (aff[2], aff[3], aff[5])))
+        P = np.matrix((
+                (1, r, 1, r),
+                (1, 1, c, c),
+                (1, 1, 1, 1)))
+
+        Q = R * P
+        boxes[:,i] = Q.reshape(1,8)
+    return boxes
+
+def calc_center_L1(afnv, tsize):
+    rect = np.round(aff2image(np.matrix(afnv).T, tsize[0]))
+    inp = rect.reshape(2,4)
+
+    topleft_r = inp[0,0]
+    topleft_c = inp[1,0];
+    botleft_r = inp[0,1];
+    botleft_c = inp[1,1];
+    topright_r = inp[0,2];
+    topright_c = inp[1,2];
+    botright_r = inp[0,3];
+    botright_c = inp[1,3];
+
+    center=[(topleft_c + botright_c)/2.0, (topleft_r+botright_r)/2.0]
+    r = [topleft_c,topleft_r,botright_c-topleft_c+1,botright_r-topleft_r+1]
+
+    return r, center

butil/calc_seq_err_robust.py

@@ -0,0 +1,92 @@
+import butil
+import math
+
+def calc_seq_err_robust(results, rect_anno):
+    seq_length = int(results['len'])
+    res = results['res']
+    centerGT = [[r[0]+(r[2]-1)/2.0, r[1]+(r[3]-1)/2.0] for r in rect_anno]
+
+    rectMat = [[0, 0, 0, 0]] * seq_length
+
+    resultType = results['type']
+    if resultType == 'rect':
+        rectMat = res
+    elif resultType == 'ivtAff':
+        for i in range(seq_length):
+            # rect, c, corn = butil.calc_rect_center(results['tmplsize'], res[i])
+            rect = butil.rect_affine_IVT(results['tmplsize'][0], res[i])
+            rectMat[i] = rect
+    elif resultType == 'L1Aff':
+        for i in range(seq_length):
+            # rect, c = butil.calc_center_L1(res[i], results['tmplsize'])
+            rect = butil.rect_affine_L1(results['tmplsize'][0], res[i])
+            rectMat[i] = rect
+    elif resultType == 'LK_Aff':
+        for i in range(seq_length):
+            rect = butil.rect_affine_LK(results['tmplsize'][0], 
+                res[2*i:2*(i+1)])
+            rectMat[i] = rect
+    elif resultType == '4corner':
+        for i in range(seq_length):
+            # corner = res[2*i:2*(i+1)]
+            # rectMat[i] = butil.d_to_f(m.corenr2rect(corner, nargout=1)[0])
+            rect = butil.rect_4corners(res[2*i:2*(i+1)])
+            rectMat[i] = rect
+    elif resultType == 'affine':
+        for i in range(seq_length):
+            rect = butil.rect_4corners(res[2*i:2*(i+1)])
+            rectMat[i] = rect
+    elif resultType == 'SIMILARITY':
+        for i in range(seq_length):
+            rect = butil.rect_similarity(results['tmplsize'][0], res[i])
+            rectMat[i] = rect
+            # wapr_p = m.parameters_to_projective_matrix(resultType, res[i],
+            #     nargout=1)
+            # corenr, c = m.getLKcorner(wapr_p, results['tmplsize'], nargout=2)
+            # rectMat[i] = butil.do_to_f(m.corner2rect(corner, nargout=1)[0])
+
+    rectMat[0] = rect_anno[0]
+    center = [[r[0]+(r[2]-1)/2.0, r[1]+(r[3]-1)/2.0] for r in rectMat]
+    errCenter = [round(butil.ssd(center[i], centerGT[i]),4)
+        for i in range(seq_length)]
+
+    idx = [sum([x>0 for x in r])==4 for r in rect_anno]
+    tmp = calc_rect_int(rectMat, rect_anno)
+
+    errCoverage = [-1] * seq_length
+    totalerrCoverage = 0
+    totalerrCenter = 0
+
+    for i in range(seq_length):
+        if idx[i]:
+            errCoverage[i] = tmp[i]
+            totalerrCoverage += errCoverage[i]
+            totalerrCenter += errCenter[i]
+        else:
+            errCenter[i] = -1
+
+    aveErrCoverage = totalerrCoverage / float(sum(idx))
+    aveErrCenter = totalerrCenter / float(sum(idx))
+
+    return aveErrCoverage, aveErrCenter, errCoverage, errCenter
+
+def calc_rect_int(A, B):
+    leftA = [a[0] for a in A]
+    bottomA = [a[1] for a in A]
+    rightA = [leftA[i] + A[i][2] - 1 for i in range(len(A))]
+    topA = [bottomA[i] + A[i][3] - 1 for i in range(len(A))]
+
+    leftB = [b[0] for b in B]
+    bottomB = [b[1] for b in B]
+    rightB = [leftB[i] + B[i][2] - 1 for i in range(len(B))]
+    topB = [bottomB[i] + B[i][3] - 1 for i in range(len(B))]
+
+    overlap = []
+    for i in range(len(leftA)):
+        tmp = (max(0, min(rightA[i], rightB[i]) - max(leftA[i], leftB[i])+1)
+            * max(0, min(topA[i], topB[i]) - max(bottomA[i], bottomB[i])+1))
+        areaA = A[i][2] * A[i][3]
+        areaB = B[i][2] * B[i][3]
+        overlap.append(tmp/float(areaA+areaB-tmp))
+
+    return overlap

butil/eval_results.py

@@ -0,0 +1,116 @@
+from config import *
+from model.attribute import *
+from model.result import Result
+import butil 
+
+def calc_result(tracker, seqs, results, evalType):
+    # if not len(results) == len(seqs):
+    #     print "length of results({0}) & sequences({1}) are not equal."
+    #         .format(len(results), len(seqs))
+    #     return
+
+    seqResultList = dict((s.name,list()) for s in seqs)
+    for i in range(len(results)):
+        subResults = results[i]
+        try:
+            seq = next(seq for seq in seqs if seq.name.lower() == subResults[0]['seq_name'].lower())
+            seq.aveCoverage = []
+            seq.aveErrCenter = []
+            seq.errCoverage = []
+            seq.errCenter = []
+        except:
+            print "Cannot find sequence '{0}'".format(subResults[0]['seq_name'])
+
+        if evalType == 'SRE':
+            idxNum = len(subResults)
+            anno = seq.subAnno[0]
+        elif evalType == 'TRE':
+            idxNum = len(subResults)
+        elif evalType == 'OPE':
+            idxNum = 1
+            anno = seq.subAnno[0]
+
+        for j in range(idxNum):
+            result = subResults[j]
+            if evalType == 'TRE':
+                anno = seq.subAnno[j]
+            try:
+                aveCoverage, aveErrCenter, errCoverage, errCenter = \
+                    butil.calc_seq_err_robust(result, anno)
+                seq.aveCoverage.append(aveCoverage)
+                seq.aveErrCenter.append(aveErrCenter)
+                seq.errCoverage += errCoverage
+                seq.errCenter += errCenter
+            except:
+                print "calcSeqErrRobust failed for '{0}', {1}/{2}".format(
+                    seq.name, len(anno), len(result['res']))
+
+            seqName = seq.name
+            startFrame = int(result['startFrame'])
+            endFrame = startFrame + int(result['len']) - 1
+            resType = result['type']
+            res = butil.matlab_double_to_py_float(result['res'])
+
+            if evalType == 'SRE':
+                mResult = Result(tracker, seqName, startFrame, endFrame, 
+                    resType, evalType, res, result['shiftType'])
+            else:
+                mResult = Result(tracker, seqName, startFrame, endFrame, 
+                    resType, evalType, res, 'None')
+            seqResultList[seqName].append(mResult)
+        #end for j
+    # end for i
+
+    attrList = getAttrList()
+    allAttr = Attribute.getAttrFromLine("ALL\tall")
+    allSuccessRateList = []
+    for attr in attrList:
+        successRateList = []
+        for seq in seqs:
+            if attr.name in seq.attributes:
+                seqSuccessList = []
+                length = len(seq.errCoverage)
+                for threshold in thresholdSetOverlap:
+                	seqSuccess = [score for score in seq.errCoverage 
+                        if score > threshold]
+                	seqSuccessList.append(len(seqSuccess)/float(length))
+                successRateList.append(seqSuccessList)
+                allSuccessRateList.append(seqSuccessList)
+
+                overlapList = [score for score in seq.errCoverage 
+                    if score > 0]
+                overlapScore = sum(overlapList) / len(overlapList)
+                attr.overlapScores.append(overlapScore)	
+                allAttr.overlapScores.append(overlapScore)
+
+                THRESHOLD = 0.5
+                errorNum = len([score for score in seq.errCoverage 
+                    if score < THRESHOLD]) / float(length) * 10
+                attr.errorNum.append(errorNum)
+                allAttr.errorNum.append(errorNum)
+
+        if len(attr.overlapScores) > 0 :
+            attr.overlap = sum(attr.overlapScores) / len(attr.overlapScores) * 100
+
+        if len(attr.errorNum) > 0 :
+            attr.error = sum(attr.errorNum) / len(attr.errorNum)
+
+        if len(successRateList) > 0:
+            for i in range(len(thresholdSetOverlap)):
+                attr.successRateList.append(
+                    sum([rates[i] for rates in successRateList]) / float(len(successRateList)))
+
+    if len(allAttr.overlapScores) > 0 :
+        allAttr.overlap = sum(allAttr.overlapScores) / len(allAttr.overlapScores) * 100
+
+    if len(allAttr.errorNum) > 0 :
+        allAttr.error = sum(allAttr.errorNum) / len(allAttr.errorNum)
+
+    if len(allSuccessRateList) > 0:
+        for i in range(len(thresholdSetOverlap)):
+           allAttr.successRateList.append(
+                sum([rates[i] for rates in allSuccessRateList]) /float(len(allSuccessRateList)))
+
+    attrList.append(allAttr)
+    attrList.sort()
+    return seqResultList, attrList