'Accumulate per image evaluation results and store the result in self.eval
:param p: input params for evaluation
:return: None'

def accumulate(self, p=None):

    print 'Accumulating    evaluation    results...'
    tic = time.time()
    if (not self.evalImgs):
        print 'Please    run    evaluate()    first'
    if (p is None):
        p = self.params
    p.catIds = (p.catIds if (p.useCats == 1) else [(-1)])
    T = len(p.iouThrs)
    R = len(p.recThrs)
    K = (len(p.catIds) if p.useCats else 1)
    A = len(p.areaRng)
    M = len(p.maxDets)
    precision = (- np.ones((T, R, K, A, M)))
    recall = (- np.ones((T, K, A, M)))
    _pe = self._paramsEval
    catIds = (_pe.catIds if _pe.useCats else [(-1)])
    setK = set(catIds)
    setA = set(map(tuple, _pe.areaRng))
    setM = set(_pe.maxDets)
    setI = set(_pe.imgIds)
    k_list = [n for (n, k) in enumerate(p.catIds) if (k in setK)]
    m_list = [m for (n, m) in enumerate(p.maxDets) if (m in setM)]
    a_list = [n for (n, a) in enumerate(map((lambda x: tuple(x)), p.areaRng)) if (a in setA)]
    i_list = [n for (n, i) in enumerate(p.imgIds) if (i in setI)]
    I0 = len(_pe.imgIds)
    A0 = len(_pe.areaRng)
    for (k, k0) in enumerate(k_list):
        Nk = ((k0 * A0) * I0)
        for (a, a0) in enumerate(a_list):
            Na = (a0 * I0)
            for (m, maxDet) in enumerate(m_list):
                E = [self.evalImgs[((Nk + Na) + i)] for i in i_list]
                E = [e for e in E if (not (e is None))]
                if (len(E) == 0):
                    continue
                dtScores = np.concatenate([e['dtScores'][0:maxDet] for e in E])
                inds = np.argsort((- dtScores), kind='mergesort')
                dtm = np.concatenate([e['dtMatches'][:, 0:maxDet] for e in E], axis=1)[:, inds]
                dtIg = np.concatenate([e['dtIgnore'][:, 0:maxDet] for e in E], axis=1)[:, inds]
                gtIg = np.concatenate([e['gtIgnore'] for e in E])
                npig = np.count_nonzero((gtIg == 0))
                if (npig == 0):
                    continue
                tps = np.logical_and(dtm, np.logical_not(dtIg))
                fps = np.logical_and(np.logical_not(dtm), np.logical_not(dtIg))
                tp_sum = np.cumsum(tps, axis=1).astype(dtype=np.float)
                fp_sum = np.cumsum(fps, axis=1).astype(dtype=np.float)
                for (t, (tp, fp)) in enumerate(zip(tp_sum, fp_sum)):
                    tp = np.array(tp)
                    fp = np.array(fp)
                    nd = len(tp)
                    rc = (tp / npig)
                    pr = (tp / ((fp + tp) + np.spacing(1)))
                    q = np.zeros((R,))
                    if nd:
                        recall[(t, k, a, m)] = rc[(-1)]
                    else:
                        recall[(t, k, a, m)] = 0
                    pr = pr.tolist()
                    q = q.tolist()
                    for i in range((nd - 1), 0, (-1)):
                        if (pr[i] > pr[(i - 1)]):
                            pr[(i - 1)] = pr[i]
                    inds = np.searchsorted(rc, p.recThrs, side='left')
                    try:
                        for (ri, pi) in enumerate(inds):
                            q[ri] = pr[pi]
                    except:
                        pass
                    precision[t, :, k, a, m] = np.array(q)
    self.eval = {'params': p, 'counts': [T, R, K, A, M], 'date': datetime.datetime.now().strftime('%Y-%m-%d    %H:%M:%S'), 'precision': precision, 'recall': recall}
    toc = time.time()
    print 'DONE    (t={:0.2f}s).'.format((toc - tic))
