def buildDataSetWithHighOverlap(positivesFeatures, logData, topKPositives, featuresDir, featuresExt): allPos, allPosIdx, ari, osi = training.readPositivesData(positivesFeatures) detections = [ x[0:5] + [float(x[6]), x[7]] for x in logData[0:2 * topKPositives] ] detections = [x for x in detections if x[6] == '1' and x[5] >= minOverlap] pos = np.zeros((len(detections), allPos.shape[1])) posIdx = [] for i in range(len(detections)): imgName = detections[i][0] box = map(float, detections[i][1:5]) bestOverlap, bestIdx, idx = 0.0, 0, 0 for truePos in allPosIdx: if truePos[0] == imgName: ov = det.IoU(box, map(float, truePos[1:5])) if ov > bestOverlap: bestOverlap = ov bestIdx = idx idx += 1 pos[i, :] = allPos[bestIdx, :] posIdx.append(allPosIdx[bestIdx]) print 'Positive Matrix with High Overlaping Detections (' + str( pos.shape[0]) + ' instances)' return (pos, posIdx, ari, osi)
def run(self,img,features,bboxes): if self.model: features,bboxes = self.rank(img,features,bboxes) if features == None: return ([],[],[],[]) positives,negatives = [],[] imageData = self.groundTruths[img] for i in range( len(bboxes) ): isPositive,isNegative = False,False for j in imageData: o = det.IoU(j,map(float,bboxes[i][1:])) if o >= 0.85: isPositive = True break elif self.overlap >= o and o > 0: isNegative = True if isPositive: positives.append(i) if isNegative: negatives.append(i) if self.model: negatives.reverse() else: cu.rnd.shuffle(negatives) posIdx = [bboxes[t] for t in positives] posFeat = [features[positives]] negIdx = [bboxes[t] for t in negatives[0:self.maxNegatives]] negFeat = [features[negatives[0:self.maxNegatives]]] return (posIdx,posFeat,negIdx,negFeat)
def intersectWithGroundTruth(A, gt): s = len(A) R = np.zeros((s, s)) for i in range(s): for j in range(s): maxIou, maxOv, maxCov = 0., 0., [0., []] for k in gt: iou = det.IoU(A[i][j], k) ov = det.overlap(k, A[i][j]) cov = det.overlap(A[i][j], k) if iou > maxIou: maxIou = iou if ov > maxOv: maxOv = ov if cov > maxCov[0]: maxCov = [cov, k] #R[i,j] = maxOv #continue if maxIou >= 0.7: # Relative size is roughly the same R[i, j] = 1. #elif maxOv >= 0.7: # The object covers this area almost completely # R[i,j] = 1. elif maxCov[0] >= 0.7: # The object is covered by the area ox = maxCov[1][0] + (maxCov[1][2] - maxCov[1][0]) / 2. oy = maxCov[1][1] + (maxCov[1][3] - maxCov[1][1]) / 2. aw = A[i][j][2] - A[i][j][0] ah = A[i][j][3] - A[i][j][1] ax = A[i][j][0] + aw / 2. ay = A[i][j][1] + ah / 2. r = 0.2 if (ax - r * aw <= ox and ox <= ax + r * aw) and (ay - r * ah <= oy and oy <= ay + r * ah): R[i, j] = 1. return R
def scoreProposals(scoringAreas, imgProp): propScores = [] for box in imgProp: boxScore = 0.0 for sarea in scoringAreas: boxScore += det.IoU(box[1:], sarea[0:4]) * sarea[4] propScores.append(boxScore) return propScores
def matchBoxes(self, box, gt): maxIoU = -1. maxIdx = 0 for i in range(len(gt)): iou = det.IoU(box, gt[i]) if iou > maxIoU: maxIoU = iou maxIdx = i return (maxIoU, maxIdx)
def matchBoxes(self, box): maxIoU = -1. maxIdx = 0 for i in range(len(self.boxes)): if self.control['DONE'][i]: continue iou = det.IoU(box, self.boxes[i]) if iou > maxIoU: maxIoU = iou maxIdx = i return (maxIoU, maxIdx)
def mapToGroundTruth(img, box, groundTruths): result = {} for cat in groundTruths.keys(): try: annotations = groundTruths[cat][img] except: continue for gt in annotations: iou = det.IoU(box, gt) rel = findRelation(box, gt, iou) if rel != None: result[cat+'_'+rel] = iou #if len(result.keys()) > 1: # print result return result
def findBigMatches(img, big, tight): layouts = [] idealMatch = [0.25, 1.0] for i in range(len(big)): b = big[i] for j in range(len(tight)): t = tight[j] r = [det.IoU(b[1:], t[1:]), det.overlap(b[1:], t[1:])] if 0.8 >= r[0] and r[1] >= 0.8: s = b[0] + t[0] ol = ObjectLayout(img) ol.addRootAndContext(t, b, r) layouts.append(ol) layouts.sort(key=lambda x: x.getScore(), reverse=True) return layouts
def selectBestBoxes(detections, groundTruth, minOverlap): candidates = [] for d in detections: try: boxes = groundTruth[d[0]] except: continue bestIoU = 0.0 for gt in boxes: iou = det.IoU(d[2:6], gt) if iou > bestIoU: bestIoU = iou print bestIoU if bestIoU > minOverlap: candidates.append(d) return candidates
def findInsideMatches(inside, layouts): idealMatch = [0.25, 1.0] for i in range(len(layouts)): t = layouts[i].root candidates = [] for j in range(len(inside)): n = inside[j] r = [det.IoU(n[1:], t[1:]), det.overlap(t[1:], n[1:])] if 0.8 >= r[0] and r[1] >= 0.8: s = np.exp(-dist(idealMatch, r)) candidates.append([j, s, n[0], r]) if len(candidates) > 0: candidates.sort(key=lambda x: x[1] + x[2], reverse=True) for k in range(min(MAX_NUMBER_OF_PARTS, len(candidates))): layouts[i].addPart(inside[candidates[k][0]], candidates[k][-1]) layouts.sort(key=lambda x: x.getScore(), reverse=True) return layouts
def loadScores(memDir, featuresDir, categoryIndex): totalNumberOfBoxes = 0 sumOfPercentBoxesUsed = 0 totalImages = 0 scoredDetections = {} for f in os.listdir(memDir): imageName = f.replace('.txt', '') totalImages += 1 data = json.load(open(memDir + f, 'r')) features = scipy.io.loadmat(featuresDir + imageName + '.mat') boxes = [] scores = [] time = [] t = 0 for boxSet in data['boxes']: for box in boxSet: # Find scores for this box for i in range(features['boxes'].shape[0]): iou = det.IoU(box, features['boxes'][i, :].tolist()) if iou == 1.0: scores.append(features['scores'][i, categoryIndex]) break boxes.append(box) time.append(t) t += 1 scoredDetections[imageName] = { 'boxes': boxes, 'scores': scores, 'time': time } totalNumberOfBoxes += len(boxes) percentBoxesUsed = 100 * (float(len(boxes)) / features['boxes'].shape[0]) sumOfPercentBoxesUsed += percentBoxesUsed print imageName, 'boxes:', len(boxes), '({:5.2f}% of {:4})'.format( percentBoxesUsed, features['boxes'].shape[0]), 'scores:', len(scores) #if totalImages > 5: break maxTime = np.max(time) print 'Average boxes per image: {:5.1f}'.format(totalNumberOfBoxes / float(totalImages)) print 'Average percent of boxes used: {:5.2f}%'.format( sumOfPercentBoxesUsed / float(totalImages)) return scoredDetections, maxTime
def createNegativeWindows(width, height, boxes, windowSize, stride): regions = [] for j in range((height - windowSize) / stride): for i in range((width - windowSize) / stride): x1 = i * stride + 1 y1 = j * stride + 1 x2 = x1 + windowSize y2 = y1 + windowSize box = [x1,y1,x2,y2] maxOv = 0 for b in boxes: ov1 = det.IoU(b, box) if ov1 > maxOv: maxOv = ov1 if maxOv >= 0.5: info = [1, maxOv] else: info = [0, maxOv] regions.append( info + box ) return regions
# b = filteredBoxes[i] # print b[0] + ' {:.8f} {:} {:} {:} {:}\n'.format(filteredScores[i],b[1],b[2],b[3],b[4]) det.showDetections('/home/caicedo/data/allimgs/' + testImage + '.jpg', filteredBoxes, filteredScores, True) det.showDetections('/home/caicedo/data/allimgs/' + testImage + '.jpg', candidateBoxes, candidateScores, False) det.showBestMatches('/home/caicedo/data/allimgs/' + testImage + '.jpg', candidateBoxes, candidateScores, groundTruth[testImage]) sys.exit() import matplotlib.pyplot as plt features = np.asmatrix(features) K = features * features.T N = np.diag(K) D = np.tile(np.mat(N).T, (1, K.shape[0])) + np.tile(np.mat(N), (K.shape[0], 1)) - 2 * K plt.imshow(G) plt.colorbar() plt.show() boxes = [map(float, x[1:]) for x in bboxes] O = np.zeros(G.shape) for i in range(O.shape[0]): for j in range(O.shape[1]): O[i, j] = det.IoU(boxes[i], boxes[j]) plt.imshow(O) plt.colorbar() plt.show()
def validRegion(b1, b2): ov = det.overlap(b1, b2) if ov > 0.9: return ov else: return det.IoU(b1, b2)
try: overlapsImages[o[0]].append( o[1:] ) except: overlapsImages[o[0]] = [ o[1:] ] print 'Total images => Scores:',len(scoresImages),'Overlaps:',len(overlapsImages) perfectMatches = 0 selectedRecords = {} for img in scoresImages.keys(): selectedRecords[img] = [] for i in range(len(scoresImages[img])): b1 = map(float, scoresImages[img][i][1:5]) maxIoU = 0.0 bestMatch = -1 for j in range(len(overlapsImages[img])): b2 = map(float, overlapsImages[img][j][0:4]) iou = det.IoU(b1,b2) if iou > maxIoU: bestMatch = j maxIoU = iou if maxIoU == 1.0: perfectMatches += 1 selectedRecords[img].append( scoresImages[img][i][1:5] + [scoresImages[img][i][0]] + overlapsImages[img][bestMatch][-2:] ) del overlapsImages[img][bestMatch] print 'Perfect matches:',perfectMatches out = open(outFile, 'w') for img in selectedRecords.keys(): for r in selectedRecords[img]: out.write(img + ' ' + ' '.join(r) + '\n' ) out.close()
import os, sys import utils as cu import libDetection as ldet import numpy as np params = cu.loadParams('scoresFile groundTruth relation output') scores = [x.split() for x in open(params['scoresFile'])] ground = cu.loadBoxIndexFile(params['groundTruth']) scores.sort(key=lambda x: float(x[1]), reverse=True) if params['relation'] == 'big': operator = lambda x, y: np.exp(-((1.0 - ldet.overlap(x, y))**2 + (0.25 - ldet.IoU(x, y))**2)) >= 0.7 if params['relation'] == 'inside': operator = lambda x, y: np.exp(-((1.0 - ldet.overlap(y, x))**2 + (0.25 - ldet.IoU(x, y))**2)) >= 0.7 if params['relation'] == 'tight': operator = lambda x, y: ldet.IoU(x, y) >= 0.5 out = open(params['output'], 'w') for s in scores: box = map(float, s[2:7]) img = s[0] try: gtBoxes = ground[img] except: gtBoxes = [] match = '0' for gt in gtBoxes: if operator(box, gt): match = '1'
def tight(box, gt, a=0.9): iou = det.IoU(box, gt) return iou >= a
counts = {'big': {'tp':0,'tn':0,'fp':0,'fn':0}, 'tight':{'tp':0,'tn':0,'fp':0,'fn':0}, 'inside':{'tp':0,'tn':0,'fp':0,'fn':0}} allBoxes = 0 for img in results.keys(): try: boxes = groundTruths[img] imageOK = True except: imageOK = False if imageOK: out = open(params['outputDir']+'/'+img+'.region_rank','w') for box in results[img].keys(): allBoxes += 1 maxIoU,assigned = 0,[0,0,0,0] for gt in groundTruths[img]: iou = det.IoU(results[img][box]['box'],gt) if iou > maxIoU: assigned = gt maxIoU = iou res = evaluateType(results[img][box],assigned,threshold) for r in res.keys(): counts[r][res[r]] += 1 if res[ results[img][box]['type'] ] == 'tp': correct = '1' else: correct = '0' out.write( img + ' ' + results[img][box]['score'] + ' ' + box + ' ' + results[img][box]['type'] + ' ' + correct + '\n') out.close() print 'AllBoxes:',allBoxes for type in counts.keys():
def inside(box, gt, a=1.0, b=0.3, c=0.2): ov = det.overlap(gt, box) iou = det.IoU(box, gt) return ov >= a and iou <= b and iou >= c
def background(box, gt): ov = det.overlap(box, gt) iou = det.IoU(box, gt) return ov < 0.3 and iou < 0.3
except: labels[d[0]] = [r] categories.add(d[1]) categories = list(categories) categories.sort() C = dict([(categories[c], c) for c in range(len(categories))]) print 'Identifying labeled boxes' L = np.zeros((M['B'].shape[0], 60), np.int32) for img in labels.keys(): print img idx = T[img] for j in range(idx['s'], idx['e']): box = M['B'][j, :].tolist() for l in labels[img]: iou = det.IoU(box, l[1:]) if iou == 1.0: L[j, C[l[0]]] = 1 archive['labels'] = L scipy.io.savemat(params['outputDir'] + '/boxes.mat', {'boxes:': M['B']}, do_compression=True) scipy.io.savemat(params['outputDir'] + '/scores.mat', {'scores:': M['S']}) scipy.io.savemat(params['outputDir'] + '/labels.mat', {'labels:': L}) scipy.io.savemat(params['outputDir'] + '/index.mat', { 'index:': index, 'images': T.keys() }, do_compression=True)
def big(box, gt, a=0.9, b=0.3, c=0.2): ov = det.overlap(box, gt) iou = det.IoU(box, gt) return ov >= a and iou <= b and iou >= c
def rankImages(self): keys = self.groundTruth.keys() keys.sort() # Rank by number of objects in the scene (from many to few) objectCounts = [len(self.groundTruth[k]) for k in keys] countRank = np.argsort(objectCounts)[::-1] countDist = dict([(i, 0) for i in range(max(objectCounts) + 1)]) for o in objectCounts: countDist[o] += 1 print 'Distribution of object counts (# objects vs # images):', countDist print 'Images with largest number of objects:', [ keys[i] for i in countRank[0:10] ] # Rank by object size (from small to large) minObjectArea = [min(map(det.area, self.groundTruth[k])) for k in keys] smallRank = np.argsort(minObjectArea) intervals = [(500 * 400 / i) for i in range(1, 21)] sizeDist = dict([(i, 0) for i in intervals]) for a in minObjectArea: counted = False for r in intervals: if a >= r: sizeDist[r] += 1 counted = True break if not counted: sizeDist[r] += 1 print 'Distribution of smallest objects area (area vs # images):', [ (i, sizeDist[i]) for i in intervals ] print 'Images with the smallest objects:', [ keys[i] for i in smallRank[0:10] ] # Rank by object size (from large to small) maxObjectArea = [max(map(det.area, self.groundTruth[k])) for k in keys] bigRank = np.argsort(minObjectArea) intervals = [(500 * 400 / i) for i in range(1, 21)] sizeDist = dict([(i, 0) for i in intervals]) for a in maxObjectArea: counted = False for r in intervals: if a >= r: sizeDist[r] += 1 counted = True break if not counted: sizeDist[r] += 1 print 'Distribution of biggest objects area (area vs # images):', [ (i, sizeDist[i]) for i in intervals ] print 'Images with the biggest objects:', [ keys[i] for i in bigRank[0:10] ] # Rank images by instance occlusion (from very occluded to isolated) maxInstanceOcclusion = [] for k in keys: if len(self.groundTruth[k]) == 1: maxInstanceOcclusion.append(0) else: maxIoU = 0 for i in range(len(self.groundTruth[k])): for j in range(i + 1, len(self.groundTruth[k])): iou = det.IoU(self.groundTruth[k][i], self.groundTruth[k][j]) if iou > maxIoU: maxIoU = iou maxInstanceOcclusion.append(maxIoU) occlusionRank = np.argsort(maxInstanceOcclusion)[::-1] intervals = [1.0 / i for i in range(1, 21)] occlusionDist = dict([(i, 0) for i in intervals]) for o in maxInstanceOcclusion: counted = False for r in intervals: if o >= r: occlusionDist[r] += 1 counted = True break if not counted: occlusionDist[r] += 1 print 'Distribution of object occlusion (occlusion vs # images):', [ (i, occlusionDist[i]) for i in intervals ] print 'Images with the most occluded objects:', [ keys[i] for i in occlusionRank[0:10] ] # Rank combination rank = dict([(k, 0) for k in keys]) for i in range(len(keys)): rank[keys[countRank[i]]] += i rank[keys[smallRank[i]]] += i rank[keys[occlusionRank[i]]] += i values = [rank[i] for i in keys] complexityRank = np.argsort(values) print 'More complex images:', [keys[i] for i in complexityRank[0:10]] return [keys[i] for i in occlusionRank]
mat = scipy.io.loadmat(params['matFilesDir'] + '/' + f) idx = mat['gt'] == 0 mat['feat'] = mat['feat'][idx[:, 0], :] mat['gt'] = mat['gt'][idx[:, 0], :] mat['boxes'] = mat['boxes'][idx[:, 0], :] mat['overlap'] = np.zeros((mat['feat'].shape[0], len(categories))) mat['class'] = np.zeros((mat['feat'].shape[0], 1)) duplicate = [] try: groundTruths = relations[img] except: groundTruths = [] for gt in groundTruths: for i in range(mat['boxes'].shape[0]): box = mat['boxes'][i, :].tolist() iou = det.IoU(box, gt[1:]) if iou > mat['overlap'][i, categories[gt[0]]]: mat['overlap'][i, categories[gt[0]]] = iou if iou == 1: mat['gt'][i] = 1.0 if mat['class'][i] == 0 or mat['class'][i] == categories[ gt[0]] + 1: mat['class'][i] = categories[gt[0]] + 1 else: duplicate.append({ 'row': i, 'class': categories[gt[0]] + 1 }) shift = 0 for d in duplicate: for key in ['feat', 'gt', 'boxes', 'overlap', 'class']: