(self, detpath,
                 classname,
                 cachedir,
                 ovthresh=0.5,
                 use_07_metric=True)
return rec, prec, ap
rec, prec, ap = voc_eval(detpath,
                               annopath,
                               imagesetfile,
                               classname,
                               [ovthresh],
                               [use_07_metric])
        Top level function that does the PASCAL VOC evaluation.
        detpath: Path to detections
           detpath.format(classname) should produce the detection results file.
        annopath: Path to annotations
           annopath.format(imagename) should be the xml annotations file.
        imagesetfile: Text file containing the list of images, one image per line.
        classname: Category name (duh)
        cachedir: Directory for caching the annotations
        [ovthresh]: Overlap threshold (default = 0.5)
        [use_07_metric]: Whether to use VOC07's 11 point AP computation
           (default False)
rec, prec, ap = voc_eval(detpath,
                               annopath,
                               imagesetfile,
                               classname,
                               [ovthresh],
                               [use_07_metric])
        Top level function that does the PASCAL VOC evaluation.
        detpath: Path to detections
           detpath.format(classname) should produce the detection results file.
        annopath: Path to annotations
           annopath.format(imagename) should be the xml annotations file.
        imagesetfile: Text file containing the list of images, one image per line.
        classname: Category name (duh)
        cachedir: Directory for caching the annotations
        [ovthresh]: Overlap threshold (default = 0.5)
        [use_07_metric]: Whether to use VOC07's 11 point AP computation
           (default False)
rec prec ap = voc_eval ( detpath annopath imagesetfile classname [ ovthresh ] [ use_07_metric ] ) Top level function that does the PASCAL VOC evaluation . detpath : Path to detections detpath . format ( classname ) should produce the detection results file . annopath : Path to annotations annopath . format ( imagename ) should be the xml annotations file . imagesetfile : Text file containing the list of images one image per line . classname : Category name ( duh ) cachedir : Directory for caching the annotations [ ovthresh ] : Overlap threshold ( default = 0 . 5 ) [ use_07_metric ] : Whether to use VOC07 s 11 point AP computation ( default False )
def voc_eval(self, detpath,
                 classname,
                 cachedir,
                 ovthresh=0.5,
                 use_07_metric=True):
        """rec, prec, ap = voc_eval(detpath,
                               annopath,
                               imagesetfile,
                               classname,
                               [ovthresh],
                               [use_07_metric])
        Top level function that does the PASCAL VOC evaluation.
        detpath: Path to detections
           detpath.format(classname) should produce the detection results file.
        annopath: Path to annotations
           annopath.format(imagename) should be the xml annotations file.
        imagesetfile: Text file containing the list of images, one image per line.
        classname: Category name (duh)
        cachedir: Directory for caching the annotations
        [ovthresh]: Overlap threshold (default = 0.5)
        [use_07_metric]: Whether to use VOC07's 11 point AP computation
           (default False)
        """
        # assumes detections are in detpath.format(classname)
        # assumes annotations are in annopath.format(imagename)
        # assumes imagesetfile is a text file with each line an image name
        # cachedir caches the annotations in a pickle file
        # first load gt
        if not os.path.isdir(cachedir):
            os.mkdir(cachedir)
        cachefile = os.path.join(cachedir, 'annots.pkl')
        # read list of images
        with open(self._imgsetpath.format(self._set_type), 'r') as f:
            lines = f.readlines()
        imagenames = [x.strip() for x in lines]
        if not os.path.isfile(cachefile):
            # load annots
            recs = {}
            for i, imagename in enumerate(imagenames):
                recs[imagename] = self.parse_rec(self._annopath % (imagename))
                if i % 100 == 0:
                    print('Reading annotation for {:d}/{:d}'.format(
                       i + 1, len(imagenames)))
            # save
            print('Saving cached annotations to {:s}'.format(cachefile))
            with open(cachefile, 'wb') as f:
                pickle.dump(recs, f)
        else:
            # load
            with open(cachefile, 'rb') as f:
                recs = pickle.load(f)

        # extract gt objects for this class
        class_recs = {}
        npos = 0
        for imagename in imagenames:
            R = [obj for obj in recs[imagename] if obj['name'] == classname]
            bbox = np.array([x['bbox'] for x in R])
            difficult = np.array([x['difficult'] for x in R]).astype(np.bool)
            det = [False] * len(R)
            npos = npos + sum(~difficult)
            class_recs[imagename] = {'bbox': bbox,
                                     'difficult': difficult,
                                     'det': det}

        # read dets
        detfile = detpath.format(classname)
        with open(detfile, 'r') as f:
            lines = f.readlines()
        if any(lines) == 1:

            splitlines = [x.strip().split(' ') for x in lines]
            image_ids = [x[0] for x in splitlines]
            confidence = np.array([float(x[1]) for x in splitlines])
            BB = np.array([[float(z) for z in x[2:]] for x in splitlines])

            # sort by confidence
            sorted_ind = np.argsort(-confidence)
            sorted_scores = np.sort(-confidence)
            BB = BB[sorted_ind, :]
            image_ids = [image_ids[x] for x in sorted_ind]

            # go down dets and mark TPs and FPs
            nd = len(image_ids)
            tp = np.zeros(nd)
            fp = np.zeros(nd)
            for d in range(nd):
                R = class_recs[image_ids[d]]
                bb = BB[d, :].astype(float)
                ovmax = -np.inf
                BBGT = R['bbox'].astype(float)
                if BBGT.size > 0:
                    # compute overlaps
                    # intersection
                    ixmin = np.maximum(BBGT[:, 0], bb[0])
                    iymin = np.maximum(BBGT[:, 1], bb[1])
                    ixmax = np.minimum(BBGT[:, 2], bb[2])
                    iymax = np.minimum(BBGT[:, 3], bb[3])
                    iw = np.maximum(ixmax - ixmin, 0.)
                    ih = np.maximum(iymax - iymin, 0.)
                    inters = iw * ih
                    uni = ((bb[2] - bb[0]) * (bb[3] - bb[1]) +
                           (BBGT[:, 2] - BBGT[:, 0]) *
                           (BBGT[:, 3] - BBGT[:, 1]) - inters)
                    overlaps = inters / uni
                    ovmax = np.max(overlaps)
                    jmax = np.argmax(overlaps)

                if ovmax > ovthresh:
                    if not R['difficult'][jmax]:
                        if not R['det'][jmax]:
                            tp[d] = 1.
                            R['det'][jmax] = 1
                        else:
                            fp[d] = 1.
                else:
                    fp[d] = 1.

            # compute precision recall
            fp = np.cumsum(fp)
            tp = np.cumsum(tp)
            rec = tp / float(npos)
            # avoid divide by zero in case the first detection matches a difficult
            # ground truth
            prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)
            ap = self.voc_ap(rec, prec, use_07_metric)
        else:
            rec = -1.
            prec = -1.
            ap = -1.

        return rec, prec, ap
def voc_eval ( self , detpath , classname , cachedir , ovthresh = 0.5 , use_07_metric = True ) : # assumes detections are in detpath.format(classname) # assumes annotations are in annopath.format(imagename) # assumes imagesetfile is a text file with each line an image name # cachedir caches the annotations in a pickle file # first load gt if not os . path . isdir ( cachedir ) : os . mkdir ( cachedir ) cachefile = os . path . join ( cachedir , 'annots.pkl' ) # read list of images with open ( self . _imgsetpath . format ( self . _set_type ) , 'r' ) as f : lines = f . readlines ( ) imagenames = [ x . strip ( ) for x in lines ] if not os . path . isfile ( cachefile ) : # load annots recs = { } for i , imagename in enumerate ( imagenames ) : recs [ imagename ] = self . parse_rec ( self . _annopath % ( imagename ) ) if i % 100 == 0 : print ( 'Reading annotation for {:d}/{:d}' . format ( i + 1 , len ( imagenames ) ) ) # save print ( 'Saving cached annotations to {:s}' . format ( cachefile ) ) with open ( cachefile , 'wb' ) as f : pickle . dump ( recs , f ) else : # load with open ( cachefile , 'rb' ) as f : recs = pickle . load ( f ) # extract gt objects for this class class_recs = { } npos = 0 for imagename in imagenames : R = [ obj for obj in recs [ imagename ] if obj [ 'name' ] == classname ] bbox = np . array ( [ x [ 'bbox' ] for x in R ] ) difficult = np . array ( [ x [ 'difficult' ] for x in R ] ) . astype ( np . bool ) det = [ False ] * len ( R ) npos = npos + sum ( ~ difficult ) class_recs [ imagename ] = { 'bbox' : bbox , 'difficult' : difficult , 'det' : det } # read dets detfile = detpath . format ( classname ) with open ( detfile , 'r' ) as f : lines = f . readlines ( ) if any ( lines ) == 1 : splitlines = [ x . strip ( ) . split ( ' ' ) for x in lines ] image_ids = [ x [ 0 ] for x in splitlines ] confidence = np . array ( [ float ( x [ 1 ] ) for x in splitlines ] ) BB = np . array ( [ [ float ( z ) for z in x [ 2 : ] ] for x in splitlines ] ) # sort by confidence sorted_ind = np . argsort ( - confidence ) sorted_scores = np . sort ( - confidence ) BB = BB [ sorted_ind , : ] image_ids = [ image_ids [ x ] for x in sorted_ind ] # go down dets and mark TPs and FPs nd = len ( image_ids ) tp = np . zeros ( nd ) fp = np . zeros ( nd ) for d in range ( nd ) : R = class_recs [ image_ids [ d ] ] bb = BB [ d , : ] . astype ( float ) ovmax = - np . inf BBGT = R [ 'bbox' ] . astype ( float ) if BBGT . size > 0 : # compute overlaps # intersection ixmin = np . maximum ( BBGT [ : , 0 ] , bb [ 0 ] ) iymin = np . maximum ( BBGT [ : , 1 ] , bb [ 1 ] ) ixmax = np . minimum ( BBGT [ : , 2 ] , bb [ 2 ] ) iymax = np . minimum ( BBGT [ : , 3 ] , bb [ 3 ] ) iw = np . maximum ( ixmax - ixmin , 0. ) ih = np . maximum ( iymax - iymin , 0. ) inters = iw * ih uni = ( ( bb [ 2 ] - bb [ 0 ] ) * ( bb [ 3 ] - bb [ 1 ] ) + ( BBGT [ : , 2 ] - BBGT [ : , 0 ] ) * ( BBGT [ : , 3 ] - BBGT [ : , 1 ] ) - inters ) overlaps = inters / uni ovmax = np . max ( overlaps ) jmax = np . argmax ( overlaps ) if ovmax > ovthresh : if not R [ 'difficult' ] [ jmax ] : if not R [ 'det' ] [ jmax ] : tp [ d ] = 1. R [ 'det' ] [ jmax ] = 1 else : fp [ d ] = 1. else : fp [ d ] = 1. # compute precision recall fp = np . cumsum ( fp ) tp = np . cumsum ( tp ) rec = tp / float ( npos ) # avoid divide by zero in case the first detection matches a difficult # ground truth prec = tp / np . maximum ( tp + fp , np . finfo ( np . float64 ) . eps ) ap = self . voc_ap ( rec , prec , use_07_metric ) else : rec = - 1. prec = - 1. ap = - 1. return rec , prec , ap