Exemple #1
0
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
Exemple #2
0
 def coverSample(self, idx):
     self.control['DONE'][idx] = True
     self.cover = self.boxes[idx][:]
     conflicts = []
     for j in range(len(self.control['DONE'])):
         if not self.control['DONE'][j]:
             ov = det.overlap(self.cover, self.boxes[j])
             if ov > 0.0:
                 conflicts.append((j, ov))
     conflicts.sort(key=lambda x: x[1], reverse=True)
     for j, ov in conflicts:
         nov = det.overlap(self.cover, self.boxes[j])
         if nov < 0.5:
             ib = det.intersect(self.cover, self.boxes[j])
             iw = ib[2] - ib[0] + 1
             ih = ib[3] - ib[1] + 1
             if iw > ih:  # Cut height first
                 if self.cover[1] >= ib[1]: self.cover[1] = ib[3]
                 if self.cover[3] <= ib[3]: self.cover[3] = ib[1]
             else:  # Cut width first
                 if self.cover[0] >= ib[0]: self.cover[0] = ib[2]
                 if self.cover[2] <= ib[2]: self.cover[2] = ib[0]
         elif nov >= 0.5:  # Assume the example is done for now
             self.control['DONE'][j] = True
             self.control['SKIP'][j] = True
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 coverSample(self, idx):
   self.control['DONE'][idx] = True
   self.cover = self.boxes[idx][:]
   conflicts = []
   for j in range(len(self.control['DONE'])):
     if not self.control['DONE'][j]:
       ov = det.overlap(self.cover, self.boxes[j])
       if ov > 0.0:
         conflicts.append( (j,ov) )
   conflicts.sort(key=lambda x:x[1], reverse=True)
   for j,ov in conflicts:
     nov = det.overlap(self.cover, self.boxes[j])
     if nov < 0.5:
       ib = det.intersect(self.cover, self.boxes[j])
       iw = ib[2] - ib[0] + 1
       ih = ib[3] - ib[1] + 1
       if iw > ih: # Cut height first
         if self.cover[1] >= ib[1]: self.cover[1] = ib[3]
         if self.cover[3] <= ib[3]: self.cover[3] = ib[1]
       else: # Cut width first
         if self.cover[0] >= ib[0]: self.cover[0] = ib[2]
         if self.cover[2] <= ib[2]: self.cover[2] = ib[0]
     elif nov >= 0.5: # Assume the example is done for now
       self.control['DONE'][j] = True
       self.control['SKIP'][j] = True
Exemple #5
0
def findRelation(box, gt, iou):
  if iou >= 0.6:
    return 'tight'
  else:
    ov = det.overlap(gt,box)
    if ov >= 1.0 and iou <= 0.3 and iou >= 0.2:
      return 'inside'
    ov = det.overlap(box,gt)
    if ov >= 0.9 and iou <= 0.4 and iou >= 0.2:
      return 'big'
  return None
def inside(box,gt):
  ov = ldet.overlap(gt,box)
  iou = ldet.IoU(box,gt)
  if ov >= 0.9 and iou <= 1.0 and iou >= 0.01:
    return ov
  else:
    return 0.0
Exemple #7
0
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 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 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
Exemple #10
0
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
Exemple #11
0
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 bigOverlap(box, gt):
  if ldet.overlap(box,gt) > 0.5 and ldet.IoU(box,gt) < 0.5:
    return 1.0
  else:
    return 0.0

# Main Program
if __name__ == "__main__":
  params = cu.loadParams("overlap groundTruth detections output")
  indexData = [x.split() for x in open(params['groundTruth'])]
  detectionsData = [x.split() for x in open(params['detections'])]

  overlapLimit = 1.0
  if params['overlap'].startswith('big'):
    minOverlap = float(params['overlap'].replace('big',''))
    overlapMeasure = lambda x,y: np.exp( -( (1.0-ldet.overlap(x,y))**2 + (0.25-ldet.IoU(x,y))**2 ) )
    #overlapMeasure = bigOverlap
  elif params['overlap'].startswith('tight'):
    minOverlap = float(params['overlap'].replace('tight',''))
    overlapMeasure = ldet.IoU
  elif params['overlap'].startswith('inside'):
    minOverlap = float(params['overlap'].replace('inside',''))
    overlapMeasure = lambda x,y: np.exp( -( (1.0-ldet.overlap(y,x))**2 + (0.25-ldet.IoU(x,y))**2 ) )
  elif params['overlap'].startswith('OV'):
    overlapMeasure = ldet.overlap
    minOverlap = float(params['overlap'].replace('OV',''))
  elif params['overlap'].startswith('IN'):
    overlapMeasure = inside
    minOverlap = float(params['overlap'].replace('IN',''))
  else:
    overlapMeasure = ldet.IoU
def bigOverlap(box, gt):
  if ldet.overlap(box,gt) > 0.5 and ldet.IoU(box,gt) < 0.5:
    return 1.0
  else:
    return 0.0
def background(box,gt):
  ov = det.overlap(box,gt)
  iou = det.IoU(box,gt)
  return ov < 0.3 and iou < 0.3
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
Exemple #16
0
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 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
Exemple #18
0
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
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'
  out.write(' '.join(s) + ' ' + match + '\n')
out.close()
Exemple #20
0
def background(box, gt):
    ov = det.overlap(box, gt)
    iou = det.IoU(box, gt)
    return ov < 0.3 and iou < 0.3
Exemple #21
0
def validRegion(b1, b2):
    ov = det.overlap(b1, b2)
    if ov > 0.9:
        return ov
    else:
        return det.IoU(b1, b2)
def validRegion(b1,b2):
  ov = det.overlap(b1,b2)
  if ov > 0.9:
    return ov
  else:
    return det.IoU(b1,b2)