def __init__(self, frame, rect):
x1, y1, x2, y2 = rect
w, h = map(cv2.getOptimalDFTSize, [x2 - x1, y2 - y1])
x1, y1 = (x1 + x2 - w) // 2, (y1 + y2 - h) // 2
self.pos = x, y = x1 + 0.5 * (w - 1), y1 + 0.5 * (h - 1)
self.size = w, h
#self.good = 0
img = cv2.getRectSubPix(frame, (w, h), (x, y))
self.win = cv2.createHanningWindow((w, h), cv2.CV_32F)
g = np.zeros((h, w), np.float32)
g[h // 2, w // 2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
for i in xrange(128):
a = self.preprocess(rnd_warp(img))
A = cv2.dft(a, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True)
self.H2 += cv2.mulSpectrums(A, A, 0, conjB=True)
self.update_kernel()
self.update(frame)
def update(self, frame, rate=0.125):
(x_ori, y_ori), (w, h) = self.pos, self.size
x, y = x_ori, y_ori
#best_x, best_y, best_dx, best_dy, best_psr = 0,0,0,0,0
#for y_iter in range(int(max(0, y_ori-h)), int(min(y_ori+h, frame.shape[0] - h + 1)), h//3):
# for x_iter in range(int(max(0, x_ori-w)), int(min(x_ori+w, frame.shape[1] - w + 1)), w//3):
# x, y = x_iter, y_iter
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = self.preprocess(img)
self.last_resp, (dx, dy), self.psr = self.correlate(img)
''' if self.psr > best_psr:
best_x, best_y, best_dx, best_dy = x, y, dx, dy
best_psr = self.psr'''
#self.psr = best_psr
#x, y, dx, dy = best_x, best_y, best_dx, best_dy
self.good = self.psr > 8.0
if not self.good:
return
self.pos = x + dx, y + dy
self.last_img = img = cv2.getRectSubPix(frame, (w, h), self.pos)
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums(A, A, 0, conjB=True)
self.H1 = self.H1 * (1.0 - rate) + H1 * rate
self.H2 = self.H2 * (1.0 - rate) + H2 * rate
self.update_kernel()
def init(self, frame, rect):
if frame.ndim == 3:
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rect = rect.astype(int)
rect[2:] += rect[:2]
x1, y1, x2, y2 = rect
w, h = map(cv2.getOptimalDFTSize, [x2 - x1, y2 - y1])
x1, y1 = (x1 + x2 - w) // 2, (y1 + y2 - h) // 2
self.t_center = x, y = x1 + 0.5 * (w - 1), y1 + 0.5 * (h - 1)
self.t_sz = w, h
img = cv2.getRectSubPix(frame, (w, h), (x, y))
self.win = cv2.createHanningWindow((w, h), cv2.CV_32F)
g = np.zeros((h, w), np.float32)
g[h // 2, w // 2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
self.A = np.zeros_like(self.G)
self.B = np.zeros_like(self.G)
for _i in range(128):
patch = self._preprocess(self._random_warp(img))
F = cv2.dft(patch, flags=cv2.DFT_COMPLEX_OUTPUT)
self.A += cv2.mulSpectrums(self.G, F, 0, conjB=True)
self.B += cv2.mulSpectrums(F, F, 0, conjB=True)
self._update_kernel()
self.update(frame)
def gaussianCorrelation(self, x1, x2): if(self._hogfeatures): c = np.zeros((self.size_patch[0], self.size_patch[1]), np.float32) for i in xrange(self.size_patch[2]): x1aux = x1[i, :].reshape((self.size_patch[0], self.size_patch[1])) x2aux = x2[i, :].reshape((self.size_patch[0], self.size_patch[1])) caux = cv2.mulSpectrums(fftd(x1aux), fftd(x2aux), 0, conjB = True) caux = real(fftd(caux, True)) #caux = rearrange(caux) c += caux c = rearrange(c) else: c = cv2.mulSpectrums(fftd(x1), fftd(x2), 0, conjB = True) # 'conjB=' is necessary! c = fftd(c, True) c = real(c) c = rearrange(c) if(x1.ndim==3 and x2.ndim==3): d = (np.sum(x1[:,:,0]*x1[:,:,0]) + np.sum(x2[:,:,0]*x2[:,:,0]) - 2.0*c) / (self.size_patch[0]*self.size_patch[1]*self.size_patch[2]) elif(x1.ndim==2 and x2.ndim==2): d = (np.sum(x1*x1) + np.sum(x2*x2) - 2.0*c) / (self.size_patch[0]*self.size_patch[1]*self.size_patch[2]) d = d * (d>=0) d = np.exp(-d / (self.sigma*self.sigma)) return d
def update(self, frame, rate=0.125, img_override=None):
(x, y), (w, h) = self.pos, self.size
if img_override is None:
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
else:
self.last_img = img = img_override
img = self.preprocess(img)
self.last_resp, (dx, dy), self.psr = self.correlate(img)
self.good = self.psr > self.MIN_PSR
if not self.good:
return
self.pos = x + dx, y + dy
self.last_img = img = cv2.getRectSubPix(frame, (w, h), self.pos)
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums(A, A, 0, conjB=True)
self.H1 = self.H1 * (1.0 - rate) + H1 * rate
self.H2 = self.H2 * (1.0 - rate) + H2 * rate
self.update_kernel()
def update(self, frame, rate=0.125):
(x, y), (w, h) = self.pos, self.size
self.lastPos = self.pos
#self.lastsize = self.size
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = self.preprocess(img)
self.last_resp, (dx, dy), self.psr = self.correlate(img)
if dx != 0 or dy != 0:
self.objectMoved = True
self.good = self.psr >= 3.0
if not self.good:
return
self.pos = x + dx, y + dy
self.last_img = img = cv2.getRectSubPix(frame, (w, h), self.pos)
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums(A, A, 0, conjB=True)
self.H1 = self.H1 * (1.0 - rate) + H1 * rate
self.H2 = self.H2 * (1.0 - rate) + H2 * rate
self.update_Filter()
def __init__(self, frame, rect, index, prev_id=0, reInit=False):
self.stationary_for_frames = 0
x1, y1, x2, y2 = rect
self.index = index
if not reInit:
self.id_ = MOSSE.MosseCounter
MOSSE.MosseCounter = MOSSE.MosseCounter + 1
else:
self.id_ = prev_id
w, h = map(cv2.getOptimalDFTSize, [x2 - x1, y2 - y1])
x1, y1 = (x1 + x2 - w) // 2, (y1 + y2 - h) // 2
self.pos = x, y = x1 + 0.5 * (w - 1), y1 + 0.5 * (h - 1)
self.size = w, h
img = cv2.getRectSubPix(frame, (w, h), (x, y))
self.win = cv2.createHanningWindow((w, h), cv2.CV_32F)
g = np.zeros((h, w), np.float32)
g[h // 2, w // 2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
for i in xrange(128):
a = self.preprocess(rnd_warp(img))
A = cv2.dft(a, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True)
self.H2 += cv2.mulSpectrums(A, A, 0, conjB=True)
self.update_kernel()
self.update(frame)
def gaussianCorrelation(self, x1, x2):
if(self._hogfeatures):
c = np.zeros((self.size_patch[0], self.size_patch[1]), np.float32)
for i in xrange(self.size_patch[2]):
x1aux = x1[i, :].reshape((self.size_patch[0], self.size_patch[1]))
x2aux = x2[i, :].reshape((self.size_patch[0], self.size_patch[1]))
caux = cv2.mulSpectrums(fftd(x1aux), fftd(x2aux), 0, conjB = True)
caux = real(fftd(caux, True))
#caux = rearrange(caux)
c += caux
c = rearrange(c)
else:
c = cv2.mulSpectrums(fftd(x1), fftd(x2), 0, conjB = True) # 'conjB=' is necessary!
c = fftd(c, True)
c = real(c)
c = rearrange(c)
if(x1.ndim==3 and x2.ndim==3):
d = (np.sum(x1[:,:,0]*x1[:,:,0]) + np.sum(x2[:,:,0]*x2[:,:,0]) - 2.0*c) / (self.size_patch[0]*self.size_patch[1]*self.size_patch[2])
elif(x1.ndim==2 and x2.ndim==2):
d = (np.sum(x1*x1) + np.sum(x2*x2) - 2.0*c) / (self.size_patch[0]*self.size_patch[1]*self.size_patch[2])
d = d * (d>=0)
d = np.exp(-d / (self.sigma*self.sigma))
return d
def train_scale(self, image, ini=False):
xsf = self.get_scale_sample(image)
# Adjust ysf to the same size as xsf in the first time
if ini:
totalSize = xsf.shape[0]
self.ysf = cv2.repeat(self.ysf, totalSize, 1)
# Get new GF in the paper (delta A)
new_sf_num = cv2.mulSpectrums(self.ysf, xsf, 0, conjB=True)
new_sf_den = cv2.mulSpectrums(xsf, xsf, 0, conjB=True)
new_sf_den = cv2.reduce(real(new_sf_den), 0, cv2.REDUCE_SUM)
if ini:
self.sf_den = new_sf_den
self.sf_num = new_sf_num
else:
# Get new A and new B
self.sf_den = cv2.addWeighted(self.sf_den, (1 - self.scale_lr),
new_sf_den, self.scale_lr, 0)
self.sf_num = cv2.addWeighted(self.sf_num, (1 - self.scale_lr),
new_sf_num, self.scale_lr, 0)
self.update_roi()
def update(self, frame, rate=0.125):
(x, y), (w, h) = self.pos, self.size
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = self.preprocess(img)
self.last_resp, (dx, dy), self.psr = self.correlate(img)
self.good = self.psr > 8.0
if not self.good:
self.posHist = []
return
self.pos = x + dx, y + dy
self.posHist.append(self.pos)
if len(self.posHist) > HIST_SIZE:
self.posHist.pop(0)
#std
an = np.array(self.posHist)
s = np.std(an, axis=0)
self.std = s[0] + s[1]
self.last_img = img = cv2.getRectSubPix(frame, (w, h), self.pos)
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums(A, A, 0, conjB=True)
self.H1 = self.H1 * (1.0 - rate) + H1 * rate
self.H2 = self.H2 * (1.0 - rate) + H2 * rate
self.update_kernel()
def update(self, frame, learning_rate=0.125):
# get the current's frame template and preprocess it
image = cv2.getRectSubPix(frame, self.size, self.template_center)
image = self.preprocess_frame(image)
(dx, dy), self.psr = self.correlate(image)
# PSR under 8 means that the object is occluded or tracking has failed
if self.psr < 8.0:
return
# update the templates center according to the new discovered position
self.template_center = (self.template_center[0] + dx,
self.template_center[1] + dy)
image = cv2.getRectSubPix(frame, self.size, self.template_center)
image = self.preprocess_frame(image)
image_dft = cv2.dft(
image, flags=cv2.DFT_COMPLEX_OUTPUT) # fourier transformation
# convolution (mulSpectrums: together with dft and idft, it may be used to calculate convolution
H1 = cv2.mulSpectrums(self.G, image_dft, 0, conjB=True)
H2 = cv2.mulSpectrums(image_dft, image_dft, 0,
conjB=True) # convolution
self.H1 = H1 * learning_rate + self.H1 * (1.0 - learning_rate
) # equation 11
self.H2 = H2 * learning_rate + self.H2 * (1.0 - learning_rate
) # equation 12
self.update_kernel()
def __init__(self, frame, rect):
x1, y1, x2, y2 = rect # Extract coordinates of the rectangle to be tracked
w, h = map(cv2.getOptimalDFTSize, [x2 - x1, y2 - y1])
x1, y1 = (x1 + x2 - w) // 2, (y1 + y2 - h) // 2
# 0.5 * x \in [w, h] (-1) = the centre point of the region
self.pos = x, y = x1 + 0.5 * (w - 1), y1 + 0.5 * (h - 1)
self.size = w, h
img = cv2.getRectSubPix(frame, (w, h), (x, y))
# Hanning Window
# http://en.wikipedia.org/wiki/Window_function
# http://en.wikipedia.org/wiki/Window_function#Hann_.28Hanning.29_window
self.win = cv2.createHanningWindow((w, h), cv2.CV_32F)
g = np.zeros((h, w), np.float32)
g[h // 2, w // 2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, None, cv2.DFT_COMPLEX_OUTPUT)
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
for i in xrange(128):
a = self.preprocess(rnd_warp(img))
A = cv2.dft(a, None, cv2.DFT_COMPLEX_OUTPUT)
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True)
self.H2 += cv2.mulSpectrums(A, A, 0, conjB=True)
self.update_kernel()
self.update(frame)
self.id = id(self)
def init(self, roi, image, cnnFeature):
if cnnFeature.ndim == 3:
self.feature_channel = cnnFeature.shape[2]
self.confidence = 1
self._roi = list(map(float, roi))
self.cnnFeature = cnnFeature
self._scale2img_x = image.shape[1] / cnnFeature.shape[1]
self._scale2img_y = image.shape[0] / cnnFeature.shape[0]
self._roi[0] = self._roi[0] / self._scale2img_x
self._roi[1] = self._roi[1] / self._scale2img_y
self._roi[2] = self._roi[2] / self._scale2img_x
self._roi[3] = self._roi[3] / self._scale2img_y
self.target_center[0] = self._roi[0] + self._roi[2] / 2
self.target_center[1] = self._roi[1] + self._roi[3] / 2
self._x_sz = [self._roi[2], self._roi[3]]
self._alphaf = []
self._scale_x_buffer = [] # store scale of w
self._scale_y_buffer = [] # store scale of h
self._keyFrame_buffer = []
self._x, searchingRegion = self.getTargetModel(image)
self._yf = self.createGaussianPeak(self.size_patch[0], self.size_patch[1])
# self._yf = self.createRickerPeak(self.size_patch[0], self.size_patch[1])
if self.feature_channel > 1:
for c in range(self.feature_channel):
xf = fftd(self._x[:, :, c])
kf = cv2.mulSpectrums(xf, xf, 0, conjB=True) # 'conjB=' is necessary!
self._alphaf.append(complexDivision(self._yf, kf + self.lambdar))
else:
xf = fftd(self._x)
kf = cv2.mulSpectrums(xf, xf, 0, conjB=True) # 'conjB=' is necessary!
self._alphaf.append(complexDivision(self._yf, kf + self.lambdar))
self.keyFrame = True
self.scaleUpdate(searchingRegion)
def update(self, frame, rate=0.125):
(x, y), (w, h) = self.pos, self.size
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = self.preprocess(img)
self.last_resp, (dx, dy), self.psr = self.correlate(img)
self.good = self.psr > 8.0
if not self.good:
self.stationary_for_frames = self.stationary_for_frames + 1
return
self.pos = x + dx, y + dy
if abs(dx) + abs(dy) < 1:
self.stationary_for_frames = self.stationary_for_frames + 1
else:
self.stationary_for_frames = 0
self.last_img = img = cv2.getRectSubPix(frame, (w, h), self.pos)
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums(A, A, 0, conjB=True)
self.H1 = self.H1 * (1.0 - rate) + H1 * rate
self.H2 = self.H2 * (1.0 - rate) + H2 * rate
self.update_kernel()
def update(self, frame, pos=None, rate=0.125):
# Crop template image from last position
(x, y), (w, h) = self.pos if pos is None else pos, self.size
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img = self.preprocess(img)
# Correlate, find position of object
self.last_resp, (dx, dy), self.psr = self.correlate(img)
# Break if lost tracking (don't update filter)
self.good = self.psr > 8.0
if not self.good:
return
# Cut out new image based on tracked location
self.pos = x+dx, y+dy
self.last_img = img = cv2.getRectSubPix(frame, (w, h), self.pos)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Preprocess, get DFT
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True) # G x F*
H2 = cv2.mulSpectrums( A, A, 0, conjB=True) # F x F*
# Get weighted average based on the rate (using the new image)
self.H1 = self.H1 * (1.0-rate) + H1 * rate
self.H2 = self.H2 * (1.0-rate) + H2 * rate
# Update filter
self.update_kernel()
def __init__(self, frame, rect):
x1, y1, x2, y2 = rect
self.using_lk = False
self.frameWidth = frame.shape[1]
self.frameHeight = frame.shape[0]
w, h = map(cv2.getOptimalDFTSize, [x2-x1, y2-y1])
x1, y1 = (x1+x2-w)//2, (y1+y2-h)//2
self.pos = x, y = x1+0.5*(w-1), y1+0.5*(h-1)
self.size = w, h
self.org_size = w,h
img = cv2.getRectSubPix(frame, (w, h), (x, y))
#self.win = cv2.createHanningWindow((w, h), cv2.CV_32F)
g = np.zeros((h, w), np.float32)
g[h//2, w//2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
#print "init G",self.G.shape
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
for i in xrange(128):
a = self.preprocess(rnd_warp(img),self.size)
A = cv2.dft(a, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True)
self.H2 += cv2.mulSpectrums( A, A, 0, conjB=True)
#print "init imgF:",A.shape
#print "init H1",self.H1.shape
#print "init H2",self.H2.shape
self.update_kernel()
def __init__(self, frame, rect):
org = frame.copy()
if len(frame.shape) == 3:
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
x1, y1, x2, y2 = rect
w, h = map(cv2.getOptimalDFTSize, [x2-x1, y2-y1])
x1, y1 = (x1+x2-w)//2, (y1+y2 - h)//2
self.pos = x,y = x1+0.5*(w-1), y1 + 0.5*(h-1)
self.size = w, h
img = cv2.getRectSubPix(frame, (w,h), (x,y))
self.win = cv2.createHanningWindow((w,h), cv2.CV_32F)
#expected response
g = np.zeros((h,w), np.float32)
g[h//2, w//2] = 1
g = cv2.GaussianBlur(g, (-1,-1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags = cv2.DFT_COMPLEX_OUTPUT)
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
for i in range(128):
f = self.preprocess(self.rnd_warp(img), self.win)
F = cv2.dft(f, flags = cv2.DFT_COMPLEX_OUTPUT)
self.H1 += cv2.mulSpectrums(self.G, F, 0, conjB = True)
self.H2 += cv2.mulSpectrums( F, F, 0, conjB = True)
self.update_kernel() #update kernel
self.update(frame) #
def __init__(self, frame, rect, number):
self.num = number
x1, y1, x2, y2 = rect
w, h = map(cv2.getOptimalDFTSize, [x2-x1, y2-y1])
x1, y1 = (x1+x2-w)//2, (y1+y2-h)//2
self.pos = x, y = x1+0.5*(w-1), y1+0.5*(h-1)
self.size = w, h
img = cv2.getRectSubPix(frame, (w, h), (x, y))
self.win = cv2.createHanningWindow((w, h), cv2.CV_32F)
g = np.zeros((h, w), np.float32)
g[h//2, w//2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
for i in xrange(128):
a = self.preprocess(MOSSE.rnd_warp(img))
A = cv2.dft(a, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True)
self.H2 += cv2.mulSpectrums( A, A, 0, conjB=True)
self.update_kernel()
self.update(frame)
def update(self, frame, rate = 0.125):
if self.maxcount > self.currentcount:
(x, y), (w, h) = self.pos, self.size
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = self.preprocess(img)
self.last_resp, (dx, dy), self.psr = self.correlate(img)
self.good = self.psr > 4.0 #8.0
self.currentcount = self.currentcount + 1
if not self.good:
print("NOTGOOD")
return False
self.pos = x+dx, y+dy
self.last_img = img = cv2.getRectSubPix(frame, (w, h), self.pos)
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums( A, A, 0, conjB=True)
self.H1 = self.H1 * (1.0-rate) + H1 * rate
self.H2 = self.H2 * (1.0-rate) + H2 * rate
self.update_kernel()
else:
return True
def apply_sample(self, sample):
# Preprocess, get DFT
img = self.preprocess(sample)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
# Add to sum matrices
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True) # Sum of G x F*
self.H2 += cv2.mulSpectrums( A, A, 0, conjB=True) # Sum of F x F*
def update(self, image, cnnFeature):
self.cnnFeature = cnnFeature
cx = self.target_center[0]
cy = self.target_center[1]
x, searchingRegion = self.getTargetModel(image)
if self.confidence == 0:
return self._roi, cnnFeature
x = cv2.resize(x, (self._x.shape[1], self._x.shape[0]))
loc, peak_value = self.detect(x)
self.target_center[0] = cx + loc[0] * self._scale2keyframe_x
self.target_center[1] = cy + loc[1] * self._scale2keyframe_y
self._roi[0] = self.target_center[0] - self._roi[2] / 2.0
self._roi[1] = self.target_center[1] - self._roi[3] / 2.0
self.scaleUpdate(searchingRegion)
self._roi[2] = self._x_sz[0] * self._scale2keyframe_x
self._roi[3] = self._x_sz[1] * self._scale2keyframe_y
self._roi[0] = cx - self._roi[2] / 2.0
self._roi[1] = cy - self._roi[3] / 2.0
self.roiCheck(cnnFeature.shape[0], cnnFeature.shape[1])
if self.confidence == 0:
return [0, 0, 0, 0], searchingRegion
x, searchingRegion = self.getTargetModel(image)
x = cv2.resize(x, (self._x.shape[1], self._x.shape[0]))
# self._yf = self.createGaussianPeak(x.shape[0], x.shape[1])
# if self.keyFrame:
# interp_factor = self.interp_factor
# else:
# interp_factor = 0.2
interp_factor = self.interp_factor
if self.feature_channel > 1:
for c in range(self.feature_channel):
xf = fftd(x[:, :, c])
kf = cv2.mulSpectrums(xf, xf, 0, conjB=True) # 'conjB=' is necessary!
alphaf = complexDivision(self._yf, kf + self.lambdar)
self._x[:, :, c] = (1 - interp_factor) * self._x[:, :, c] + interp_factor * x[:, :, c]
self._alphaf[c] = (1 - interp_factor) * self._alphaf[c] + interp_factor * alphaf
else:
xf = fftd(x)
kf = cv2.mulSpectrums(xf, xf, 0, conjB=True) # 'conjB=' is necessary!
alphaf = complexDivision(self._yf, kf + self.lambdar)
self._x = (1 - interp_factor) * self._x + interp_factor * x
self._alphaf[0] = (1 - interp_factor) * self._alphaf[0] + interp_factor * alphaf
# # return tracking result
target_roi = [self._roi[0] * self._scale2img_x, self._roi[1] * self._scale2img_y, self._roi[2] * self._scale2img_x, self._roi[3] * self._scale2img_y]
return target_roi, searchingRegion
def gaussianCorrelation(self, x1, x2):
if self._hogfeatures:
c = np.zeros((self.size_patch[0], self.size_patch[1]), np.float32)
for i in range(self.size_patch[2]):
x1aux = x1[i, :].reshape((self.size_patch[0], self.size_patch[1]))
x2aux = x2[i, :].reshape((self.size_patch[0], self.size_patch[1]))
caux = cv2.mulSpectrums(fftd(x1aux), fftd(x2aux), 0, conjB=True)
#print('x1aux x2aux: ',x1aux.shape, x2aux.shape)
caux = real(fftd(caux, True))
# caux = rearrange(caux)
c += caux
c = rearrange(c)
elif self._cnnfeatures: # 3D cnn feat
if type(x1) == type([]):
_c = np.zeros((self.size_patch[0], self.size_patch[1]), np.float32)
c = []
for i in range(len(self.cnn_multidepth)):
c.append(_c)
#print('c:',_c.shape,'self.cnn_multidepth[i]:',self.cnn_multidepth[i])
for j in range(self.cnn_multidepth[i]):
x1aux,x2aux = x1[i][:,:,j],x2[i][:,:,j]
caux = cv2.mulSpectrums(fftd(x1aux), fftd(x2aux), 0, conjB=True)
caux = real(fftd(caux, True))
c[i] += caux
c[i] = rearrange(c[i])
else:
c = np.zeros((self.size_patch[0], self.size_patch[1]), np.float32)
for i in range(self.size_patch[2]):
x1aux,x2aux = x1[:,:,i],x2[:,:,i]
caux = cv2.mulSpectrums(fftd(x1aux), fftd(x2aux), 0, conjB=True)
caux = real(fftd(caux, True))
c += caux
c = rearrange(c)
else:
# 'conjB=' is necessary!在做乘法之前取第二个输入数组的共轭.
c = cv2.mulSpectrums(fftd(x1), fftd(x2), 0, conjB=True)
c = fftd(c, True)
c = real(c)
c = rearrange(c)
# print('c: ', c.shape)
if type(x1) == type([]): # multi-KCF
k = []
for i in range(len(self.cnn_multidepth)):
d = (np.sum(x1[i] * x1[i]) + np.sum(x2[i] * x2[i]) - 2.0 * c[i]) / (
self.size_patch[0] * self.size_patch[1] * self.cnn_multidepth[i])
d = d * (d >= 0)
d = np.exp(-d / (self.sigma * self.sigma))
k.append(d)
return k
else:
d = (np.sum(x1 * x1) + np.sum(x2 * x2) - 2.0 * c) / (
self.size_patch[0] * self.size_patch[1] * self.size_patch[2])
d = d * (d >= 0)
d = np.exp(-d / (self.sigma * self.sigma))
return d
def adapt(self, frame, pos, rate=0.125):
(w, h) = self.size
self.pos = (x,y) = pos
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums( A, A, 0, conjB=True)
self.H1 = self.H1 * (1.0-rate) + H1 * rate
self.H2 = self.H2 * (1.0-rate) + H2 * rate
self.update_kernel()
def reconstruct_ocv(self, img):
assert opencv, "No opencv present"
img2 = np.zeros((2 * self.N, 2 * self.N), dtype=np.single)
for i in range(3):
imf = cv2.mulSpectrums(cv2.dft(img[i, :, :]), self._prefilter_ocv, 0)
self._carray_ocv[0:self.N // 2, 0:self.N] = imf[0:self.N // 2, 0:self.N]
self._carray_ocv[3 * self.N // 2:2 * self.N, 0:self.N] = imf[self.N // 2:self.N, 0:self.N]
img2 = cv2.add(img2, cv2.multiply(cv2.idft(self._carray_ocv, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT),
self._reconfactor[i, :, :]))
self._imgstore = img.copy()
return cv2.idft(cv2.mulSpectrums(cv2.dft(img2), self._postfilter_ocv, 0),
flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
def reconstructframe_ocv(self, img, i):
assert opencv, "No opencv present"
diff = img - self._imgstore[i, :, :]
imf = cv2.mulSpectrums(cv2.dft(diff), self._prefilter_ocv, 0)
self._carray_ocv[0:self.N // 2, 0:self.N] = imf[0:self.N // 2, 0:self.N]
self._carray_ocv[3 * self.N // 2:2 * self.N, 0:self.N] = imf[self.N // 2:self.N, 0:self.N]
img2 = cv2.multiply(cv2.idft(self._carray_ocv, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT),
self._reconfactor[i, :, :])
self._imgstore[i, :, :] = img
self._bigimgstore = self._bigimgstore + cv2.idft(cv2.mulSpectrums(cv2.dft(img2), self._postfilter_ocv, 0),
flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
return self._bigimgstore
def adapt(self, frame, pos, rate=0.125):
(w, h) = self.size
self.pos = (x, y) = pos
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums(A, A, 0, conjB=True)
self.H1 = self.H1 * (1.0 - rate) + H1 * rate
self.H2 = self.H2 * (1.0 - rate) + H2 * rate
self.update_kernel()
def gaussian_correlation(self, cur_feat, avg_feat):
if (self._hog_features):
c = np.zeros((self._size_patch_info[0], self._size_patch_info[1]),
np.float32)
# 对每个维度进行循环检测
for i in range(self._size_patch_info[2]):
x1aux = cur_feat[i, :].reshape(
(self._size_patch_info[0], self._size_patch_info[1]))
x2aux = avg_feat[i, :].reshape(
(self._size_patch_info[0], self._size_patch_info[1]))
# BEGIN FFTD
caux = cv2.mulSpectrums(ffttools.fftd(x1aux),
ffttools.fftd(x2aux),
0,
conjB=True)
caux = ffttools.real(ffttools.fftd(caux, True))
# END FFTD
c += caux
c = ffttools.rearrange(c)
else:
# 'conjB=' is necessary!在做乘法之前取第二个输入数组的共轭.
# BEGIN FFTD，和上面的代码块做了一样的事情
c = cv2.mulSpectrums(ffttools.fftd(cur_feat),
ffttools.fftd(avg_feat),
0,
conjB=True)
# c = ffttools.fftd(c, True)
c = ffttools.real(ffttools.fftd(c, True))
# END_FFTD
c = ffttools.rearrange(c)
# 这里的作用是验证特征的维度是否相同，不同维度特征不得合到一起
# 三维特征（HOG等多特征）
if (cur_feat.ndim == 3 and avg_feat.ndim == 3):
d = (np.sum(cur_feat[:, :, 0] * cur_feat[:, :, 0]) +
np.sum(avg_feat[:, :, 0] * avg_feat[:, :, 0]) - 2.0 * c) / (
self._size_patch_info[0] * self._size_patch_info[1] *
self._size_patch_info[2])
# 二维特征（CN等单特征）
elif (cur_feat.ndim == 2 and avg_feat.ndim == 2):
d = (np.sum(cur_feat * cur_feat) + np.sum(avg_feat * avg_feat) -
2.0 * c) / (self._size_patch_info[0] *
self._size_patch_info[1] *
self._size_patch_info[2])
else:
raise Exception('Array dim error.', cur_feat.ndim)
# 核计算公式
d = d * (d >= 0)
d = np.exp(-d / (self._sigma * self._sigma))
# 返回高斯核结果
return d
def __init__(self, frame, rect):
x1, y1, x2, y2 = rect
self.using_lk = False
self.Impused = False
self.tx = 0
self.ty = 0
self.frameWidth = frame.shape[1]
self.frameHeight = frame.shape[0]
self.firstframe = frame[int(y1):int(y2),int(x1):int(x2)]
cv2.imshow('first frame',self.firstframe)
fout.write(str(x1)+','+ str(y1)+','+ str(x2)+','+ str(y2)+'\n')
org_fout.write(str(x1)+','+ str(y1)+','+ str(x2)+','+ str(y2)+'\n')
w, h = map(cv2.getOptimalDFTSize, [x2-x1, y2-y1])
x1, y1 = (x1+x2-w)//2, (y1+y2-h)//2
self.pos = x, y = x1+0.5*(w-1), y1+0.5*(h-1)
self.size = w, h
self.org_size = w,h
img = cv2.getRectSubPix(frame, (w, h), (x, y))
self.PF_number = n_PF
self.prev_PF_count = n_PF
self.f0 = np.array([])
self.f = np.array([])
self.pt = np.ones((n_PF, 2), int) * self.pos
self.last_img_PF = np.array([])
self.last_resp_PF = np.array([])
#self.win = cv2.createHanningWindow((w, h), cv2.CV_32F)
g = np.zeros((h, w), np.float32)
g[h//2, w//2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
#print "init G",self.G.shape
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
for i in xrange(128):
a = self.preprocess(rnd_warp(img),self.size)
A = cv2.dft(a, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True)
self.H2 += cv2.mulSpectrums( A, A, 0, conjB=True)
#print "init imgF:",A.shape
#print "init H1",self.H1.shape
#print "init H2",self.H2.shape
self.update_kernel()
def __prepare_convolution_terms(self):
self.G = cv2.dft(self.g, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
a = self.preprocess_frame(self.template)
# compute the DFT of the image
A = cv2.dft(a, flags=cv2.DFT_COMPLEX_OUTPUT)
# get correlation between G and A, without flags
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True)
# get correlation between A and A, without flags
self.H2 += cv2.mulSpectrums(A, A, 0, conjB=True)
def init_training_data(self, frame, count=128):
img = self.get_target_img_from_frame(frame)
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
for i in xrange(128):
a = self.preprocess(rnd_warp(img))
A = cv2.dft(a, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True)
self.H2 += cv2.mulSpectrums(A, A, 0, conjB=True)
self.update_kernel()
self.update(frame)
return self
def complexDivide(G, F) :
top = cv.mulSpectrums(G, F, flags=cv.DFT_COMPLEX_OUTPUT, conjB=True) # Top is G*(F conjugate)
bot = cv.mulSpectrums(F, F, flags=cv.DFT_COMPLEX_OUTPUT, conjB=True) # Bot is F*(F conjugate)
# Bottom is strictly real and we should divide real and complex parts by it
botRe = [np.float32(bot), np.zeros(bot.shape, np.float32)]
botRe = cv.split(bot)
botRe[1] = botRe[0].copy()
bot = cv.merge(botRe)
# Do the actual division
H = np.divide(top, bot)
return H
def cv2_convolution(image, b):
dft_m = cv2.getOptimalDFTSize(image.shape[0] + b.shape[0] - 1)
dft_n = cv2.getOptimalDFTSize(image.shape[1] + b.shape[1] - 1)
d = b.shape[0]
c = np.zeros((image.shape[0] + d - 1, image.shape[1] + d - 1), dtype='uint8')
# getting gaussian dft
dft_b = np.zeros((dft_m, dft_n), dtype='float64')
dft_b[:b.shape[0], :b.shape[1]] = b
dft_b = cv2.dft(dft_b, flags=cv2.DFT_REAL_OUTPUT)
# getting layers dft
dfts = []
new_channels = []
channels = cv2.split(image)
for i, channel in enumerate(channels):
#cv2.imshow('channel %d'%i, channel)
a = np.array(channel, dtype='float64')
dft_a = np.zeros((dft_m, dft_n), dtype='float64')
dft_a[:a.shape[0], :a.shape[1]] = a
dft_a = cv2.dft(dft_a, flags=cv2.DFT_REAL_OUTPUT)
dft_a = cv2.mulSpectrums(dft_a, dft_b, 0)
dft_a = cv2.idft(dft_a, flags= cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
tmp = dft_a[d/2:a.shape[0] + d/2, d/2:a.shape[1] + d/2]
channel = np.array(tmp, dtype='uint8')
#cv2.imshow('new channel %d'%i, channel)
new_channels.append(channel)
result = cv2.merge(new_channels)
return result
def homomorphic():
global yh, yl, c, d0, complex
du = np.zeros(complex.shape, dtype=np.float32)
#H(u, v)
for u in range(dft_M):
for v in range(dft_N):
du[u, v] = sqrt((u - dft_M / 2.0) * (u - dft_M / 2.0) +
(v - dft_N / 2.0) * (v - dft_N / 2.0))
du2 = cv2.multiply(du, du) / (d0 * d0)
re = np.exp(-c * du2)
H = (yh - yl) * (1 - re) + yl
#S(u, v)
filtered = cv2.mulSpectrums(complex, H, 0)
#inverse DFT (does the shift back first)
filtered = np.fft.ifftshift(filtered)
filtered = cv2.idft(filtered)
#normalization to be representable
filtered = cv2.magnitude(filtered[:, :, 0], filtered[:, :, 1])
cv2.normalize(filtered, filtered, 0, 1, cv2.NORM_MINMAX)
#g(x, y) = exp(s(x, y))
filtered = np.exp(filtered)
cv2.normalize(filtered, filtered, 0, 1, cv2.NORM_MINMAX)
cv2.namedWindow('homomorphic', cv2.WINDOW_NORMAL)
cv2.imshow("homomorphic", filtered)
cv2.resizeWindow("homomorphic", 600, 550)
def deconvolve(self, img):
"""Remove impulse response function from ping
Copy from https://github.com/pvazteixeira/multibeam
"""
img = np.float32(img)
img_f = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
psf_padded = np.zeros_like(img)
kh, kw = self.psf.shape
psf_padded[:kh, :kw] = self.psf
# compute (padded) psf's DFT
psf_f = cv2.dft(psf_padded, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows=kh)
psf_f_2 = (psf_f ** 2).sum(-1)
ipsf_f = psf_f / (psf_f_2 + self.noise)[..., np.newaxis]
result_f = cv2.mulSpectrums(img_f, ipsf_f, 0)
result = cv2.idft(result_f, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
result = np.roll(result, -kh // 2, 0)
result = np.roll(result, -kw // 2, 1)
# clip to 0-1 range
result[result < 0] = 0
result = (np.max(img) / np.max(result)) * result
return result.astype(np.float32)
def cv2_deconvolution(image, b):
dft_m = cv2.getOptimalDFTSize(image.shape[0] + b.shape[0] - 1)
dft_n = cv2.getOptimalDFTSize(image.shape[1] + b.shape[1] - 1)
c = np.zeros((image.shape[0] + d - 1, image.shape[1] + d - 1), dtype='uint8')
# getting gaussian dft
dft_b = np.zeros((dft_m, dft_n), dtype='float64')
dft_b[:b.shape[0], :b.shape[1]] = b
psf = cv2.dft(dft_b, flags=cv2.DFT_COMPLEX_OUTPUT)
psf2 = (psf**2).sum(-1)
ipsf = psf / (psf2 + 0.7)[..., np.newaxis]
# getting layers dft
dfts = []
new_channels = []
channels = cv2.split(image)
for i, channel in enumerate(channels):
#cv2.imshow('channel %d'%i, channel)
a = np.array(channel, dtype='float64')
dft_a = np.zeros((dft_m, dft_n), dtype='float64')
dft_a[:a.shape[0], :a.shape[1]] = a
print 'deconv'
dft_a = cv2.dft(dft_a, flags=cv2.DFT_COMPLEX_OUTPUT)
dft_a = cv2.mulSpectrums(dft_a, ipsf, 0)
print dft_a
dft_a = cv2.idft(dft_a, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
print dft_a
tmp = dft_a[d/2:a.shape[0] + d/2, d/2:a.shape[1] + d/2]
channel = np.array(tmp, dtype='uint8')
cv2.imshow('new channel %d'%i, channel)
new_channels.append(channel)
result = cv2.merge(new_channels)
return result
def aplicar_filtro(magn, filtro):
# Filtro para o domínio da frequência
fmg, ffs = tf_complexa(filtro)
# Aplicar
rmg = cv.mulSpectrums(magn, fmg, cv.DFT_ROWS)
rmg = np.fft.ifftshift(rmg, axes=None)
return rmg
def cv2_deconvolution(image, b):
dft_m = cv2.getOptimalDFTSize(image.shape[0] + b.shape[0] - 1)
dft_n = cv2.getOptimalDFTSize(image.shape[1] + b.shape[1] - 1)
c = np.zeros((image.shape[0] + d - 1, image.shape[1] + d - 1),
dtype='uint8')
# getting gaussian dft
dft_b = np.zeros((dft_m, dft_n), dtype='float64')
dft_b[:b.shape[0], :b.shape[1]] = b
psf = cv2.dft(dft_b, flags=cv2.DFT_COMPLEX_OUTPUT)
psf2 = (psf**2).sum(-1)
ipsf = psf / (psf2 + 0.7)[..., np.newaxis]
# getting layers dft
dfts = []
new_channels = []
channels = cv2.split(image)
for i, channel in enumerate(channels):
#cv2.imshow('channel %d'%i, channel)
a = np.array(channel, dtype='float64')
dft_a = np.zeros((dft_m, dft_n), dtype='float64')
dft_a[:a.shape[0], :a.shape[1]] = a
print 'deconv'
dft_a = cv2.dft(dft_a, flags=cv2.DFT_COMPLEX_OUTPUT)
dft_a = cv2.mulSpectrums(dft_a, ipsf, 0)
print dft_a
dft_a = cv2.idft(dft_a, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
print dft_a
tmp = dft_a[d / 2:a.shape[0] + d / 2, d / 2:a.shape[1] + d / 2]
channel = np.array(tmp, dtype='uint8')
cv2.imshow('new channel %d' % i, channel)
new_channels.append(channel)
result = cv2.merge(new_channels)
return result
def update(_):
ang = np.deg2rad(cv2.getTrackbarPos('angle', win))
d = cv2.getTrackbarPos('d', win)
noise = 10**(-0.1 * cv2.getTrackbarPos('SNR (db)', win))
if defocus:
pointspread = defocus_kernel(d)
else:
pointspread = motion_kernel(ang, d)
pointspread /= pointspread.sum()
pointspread_pad = np.zeros_like(img)
kh, kw = pointspread.shape
pointspread_pad[:kh, :kw] = pointspread
PSF = cv2.dft(pointspread_pad,
flags=cv2.DFT_COMPLEX_OUTPUT,
nonzeroRows=kh)
PSF2 = (PSF**2).sum(-1)
iPSF = PSF / (PSF2 + noise)[..., np.newaxis]
RES = cv2.mulSpectrums(IMG, iPSF, 0)
result = cv2.idft(RES, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
result = np.roll(result, -kh // 2, 0)
result = np.roll(result, -kw // 2, 1)
cv2.imwrite('../Generated/bot_blur.jpg', 255 * result)
cv2.destroyAllWindows()
def _polynomial_correlation(self, x1, x2, a, b):
xcorr = cv2.mulSpectrums(fft2(x1), fft2(x2), 0, conjB=True)
xcorr = fftshift(real(ifft2(xcorr)))
out = (xcorr / x1.size + a) ** b
return out
def cv2_convolution(image, b):
dft_m = cv2.getOptimalDFTSize(image.shape[0] + b.shape[0] - 1)
dft_n = cv2.getOptimalDFTSize(image.shape[1] + b.shape[1] - 1)
d = b.shape[0]
c = np.zeros((image.shape[0] + d - 1, image.shape[1] + d - 1),
dtype='uint8')
# getting gaussian dft
dft_b = np.zeros((dft_m, dft_n), dtype='float64')
dft_b[:b.shape[0], :b.shape[1]] = b
dft_b = cv2.dft(dft_b, flags=cv2.DFT_REAL_OUTPUT)
# getting layers dft
dfts = []
new_channels = []
channels = cv2.split(image)
for i, channel in enumerate(channels):
#cv2.imshow('channel %d'%i, channel)
a = np.array(channel, dtype='float64')
dft_a = np.zeros((dft_m, dft_n), dtype='float64')
dft_a[:a.shape[0], :a.shape[1]] = a
dft_a = cv2.dft(dft_a, flags=cv2.DFT_REAL_OUTPUT)
dft_a = cv2.mulSpectrums(dft_a, dft_b, 0)
dft_a = cv2.idft(dft_a, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
tmp = dft_a[d / 2:a.shape[0] + d / 2, d / 2:a.shape[1] + d / 2]
channel = np.array(tmp, dtype='uint8')
#cv2.imshow('new channel %d'%i, channel)
new_channels.append(channel)
result = cv2.merge(new_channels)
return result
def apply_channel_deconvolution (self, img, psfsize=10, snrVal=8): # Based on deconvolution.py in python samples of opencv
img = img.astype('double')/255.0
img = self.blur_edge(img)
IMG = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
if (psfsize==0): return img
defocus = True
ang = 0
d = psfsize
snr = snrVal
noise = 10**(-0.1*snr)
if defocus:
psf = self.defocus_kernel(d)
else:
psf = self.motion_kernel(ang, d)
psf /= psf.sum()
psf_pad = np.zeros_like(img)
kh, kw = psf.shape
psf_pad[:kh, :kw] = psf
PSF = cv2.dft(psf_pad, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows = kh)
PSF2 = (PSF**2).sum(-1)
iPSF = PSF / (PSF2 + noise)[...,np.newaxis]
RES = cv2.mulSpectrums(IMG, iPSF, 0)
res = cv2.idft(RES, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT )
res = np.roll(res, -kh//2, 0)
res = np.roll(res, -kw//2, 1)
return res
def fft2Conv(I, kernel, borderType=cv2.BORDER_DEFAULT):
#图像矩阵的高、宽
R, C = I.shape[:2]
#卷积核的高、宽
r, c = kernel.shape[:2]
#卷积核的半径
tb = (r - 1) / 2
lr = (c - 1) / 2
#第一步：扩充边界
I_padded = cv2.copyMakeBorder(I, tb, tb, lr, lr, borderType)
#第二步：对 I_padded 和 kernel 右侧和下侧补零
#满足二维快速傅里叶变换的行数、列数
rows = cv2.getOptimalDFTSize(I_padded.shape[0] + r - 1)
cols = cv2.getOptimalDFTSize(I_padded.shape[1] + c - 1)
#补零
I_padded_zeros = np.zeros((rows, cols), np.float64)
I_padded_zeros[:I_padded.shape[0], :I_padded.shape[1]] = I_padded
kernel_zeros = np.zeros((rows, cols), np.float64)
kernel_zeros[:kernel.shape[0], :kernel.shape[1]] = kernel
#第三步：快速傅里叶变换
fft2_Ipz = np.zeros((rows, cols, 2), np.float64)
cv2.dft(I_padded_zeros, fft2_Ipz, cv2.DFT_COMPLEX_OUTPUT)
fft2_kz = np.zeros((rows, cols, 2), np.float64)
cv2.dft(kernel_zeros, fft2_kz, cv2.DFT_COMPLEX_OUTPUT)
#第四步：两个快速傅里叶变换点乘
Ipz_rz = cv2.mulSpectrums(fft2_Ipz, fft2_kz, cv2.DFT_ROWS)
#第五步：傅里叶逆变换，并只取实部
ifft2FullConv = np.zeros((rows, cols), np.float64)
cv2.dft(Ipz_rz, ifft2FullConv,
cv2.DFT_REAL_OUTPUT + cv2.DFT_INVERSE + cv2.DFT_SCALE)
print np.max(ifft2FullConv)
#第六步：裁剪，同输入的图像矩阵尺寸一样
sameConv = np.copy(ifft2FullConv[r - 1:R + r - 1, c - 1:C + c - 1])
return sameConv
def correlate(self, img):
C = cv2.mulSpectrums(cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT), self.H, 0, conjB=True)
resp = cv2.idft(C, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
h, w = resp.shape
_, mval, _, (mx, my) = cv2.minMaxLoc(resp)
side_resp = resp.copy()
cv2.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1)
smean, sstd = side_resp.mean(), side_resp.std()
psr = (mval-smean) / (sstd+eps)
return resp, (mx-w//2, my-h//2), psr
def __init__(self, frame, rect):
# Get frame size
x1, y1, x2, y2 = rect
# Resize to fft window
w, h = map(cv2.getOptimalDFTSize, [x2-x1, y2-y1])
x1, y1 = (x1+x2-w)//2, (y1+y2-h)//2
# Store position and size relative to frame
self.pos = x, y = x1+0.5*(w-1), y1+0.5*(h-1)
self.size = w, h
# Crop template image from frame
img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Create Hanning window (weighting of values from center)
self.win = cv2.createHanningWindow((w, h), cv2.CV_32F)
# Create output image (centered Gaussian point--for correlation)
g = np.zeros((h, w), np.float32)
g[h//2, w//2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
# Save the desired output image in frequency space
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
# Create transformed variants of input
self.H1 = np.zeros_like(self.G)
self.H2 = np.zeros_like(self.G)
for i in xrange(128):
# Preprocess, get DFT
a = self.preprocess(rnd_warp(img))
A = cv2.dft(a, flags=cv2.DFT_COMPLEX_OUTPUT)
self.H1 += cv2.mulSpectrums(self.G, A, 0, conjB=True) # Sum of G x F*
self.H2 += cv2.mulSpectrums( A, A, 0, conjB=True) # Sum of F x F*
# Update filter
self.update_kernel()
self.update(frame)
def filterImg(img,filtro_magnitud):
"""Filtro para imágenes de un canal"""
#como la fase del filtro es 0 la conversión de polar a cartesiano es directa (magnitud->x, fase->y)
filtro=np.array([filtro_magnitud,np.zeros(filtro_magnitud.shape)]).swapaxes(0,2).swapaxes(0,1)
imgf=cv.dft(np.float32(img), flags=cv.DFT_COMPLEX_OUTPUT)
imgf=cv.mulSpectrums(imgf, np.float32(filtro), cv.DFT_ROWS)
return cv.idft(imgf, flags=cv.DFT_REAL_OUTPUT | cv.DFT_SCALE)
def correlate(self, img):
C = cv2.mulSpectrums(cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT), self.H, 0, conjB=True)
resp = cv2.idft(C, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
h, w = resp.shape
_, mval, _, (mx, my) = cv2.minMaxLoc(resp)
fmx = vertex(mx, *resp[my,mx-1:mx+2]) if (1 <= mx <= w-1) else mx
fmy = vertex(my, *resp[my-1:my+2,mx]) if (1 <= my <= h-1) else my
#print (mx - w//2, my - h//2), (fmx - w//2, fmy - h//2)
side_resp = resp.copy()
cv2.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1)
smean, sstd = side_resp.mean(), side_resp.std()
psr = (mval-smean) / (sstd+eps)
return resp, (fmx-w//2, fmy-h//2), psr
def get_shift(self, imgA, imgB):
rv = np.array([0.0, 0.0])
if (imgA is not None) and (imgB is not None) and (imgA.shape==imgB.shape):
# Phase correlation.
A = cv2.dft(imgA)
B = cv2.dft(imgB)
AB = cv2.mulSpectrums(A, B, flags=0, conjB=True)
normAB = cv2.norm(AB)
if (normAB != 0.0):
crosspower = AB / normAB
shift = cv2.idft(crosspower)
shift0 = np.roll(shift, int(shift.shape[0]/2), 0)
shift00 = np.roll(shift0, int(shift.shape[1]/2), 1) # Roll the matrix so 0,0 goes to the center of the image.
# Get the coordinates of the maximum shift.
kShift = np.argmax(shift00)
(iShift,jShift) = np.unravel_index(kShift, shift00.shape)
# Get weighted centroid of a region around the peak, for sub-pixel accuracy.
w = 7
r = int((w-1)/2)
i0 = clip(iShift-r, 0, shift00.shape[0]-1)
i1 = clip(iShift+r, 0, shift00.shape[0]-1)+1
j0 = clip(jShift-r, 0, shift00.shape[1]-1)
j1 = clip(jShift+r, 0, shift00.shape[1]-1)+1
peak = shift00[i0:i1].T[j0:j1].T
moments = cv2.moments(peak, binaryImage=False)
if (moments['m00'] != 0.0):
iShiftSubpixel = moments['m01']/moments['m00'] + float(i0)
jShiftSubpixel = moments['m10']/moments['m00'] + float(j0)
else:
iShiftSubpixel = float(shift.shape[0])/2.0
jShiftSubpixel = float(shift.shape[1])/2.0
# Accomodate the matrix roll we did above.
iShiftSubpixel -= float(shift.shape[0])/2.0
jShiftSubpixel -= float(shift.shape[1])/2.0
# Convert unsigned shifts to signed shifts.
height = float(shift00.shape[0])
width = float(shift00.shape[1])
iShiftSubpixel = ((iShiftSubpixel+height/2.0) % height) - height/2.0
jShiftSubpixel = ((jShiftSubpixel+width/2.0) % width) - width/2.0
rv = np.array([iShiftSubpixel, jShiftSubpixel])
return rv
def apply_filter(img, ftype, flen, ksize=-1, ori=0):
"""
Apply a particular deblur filter.
:param str ftype:
Filter type.
:param int ksize:
Kernel size.
:param int flen:
Filter length (must be strictly smaller than the kernel size).
:param int ori:
Optional kernel orientation. Unused for circular kernels.
"""
if ksize < 0:
ksize = flen
assert ksize >= flen, "kernel size must not be less than filter length"
img = np.array(img, dtype=np.float32)
# frequency domain representation of the image
img = blur_edge(img, flen)
img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
IMG = cv2.dft(img_gray, flags=cv2.DFT_COMPLEX_OUTPUT)
print(IMG)
# make the PSF for deblurring
if ftype == "linear":
psf = makeLinearKernel(ksize=ksize, flen=flen, angle=ori)
else:
psf = makeCircularKernel(ksize=ksize, flen=flen)
# perform the deconvolution
psf_pad = np.zeros_like(img_gray)
kh, kw = psf.shape
psf_pad[:kh, :kw] = psf
PSF = cv2.dft(psf_pad, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows=kh)
PSF2 = (PSF**2).sum(-1)
iPSF = PSF / (PSF2 + 10**5)[...,np.newaxis]
RES = cv2.mulSpectrums(IMG, iPSF, 0)
res = cv2.idft(RES, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
res = np.roll(res, -kh//2, 0)
res = np.roll(res, -kw//2, 1)
def correlate(self, img,size):
#print "new size in correlate",size
self.H = self.resizeFFT(self.H,size)
## H1 = cv2.resize(self.H[...,0],None,fx=lk_ratio[0], fy=lk_ratio[1], interpolation = cv2.INTER_CUBIC)
## H2 = cv2.resize(self.H[...,1],None,fx=lk_ratio[0], fy=lk_ratio[1], interpolation = cv2.INTER_CUBIC)
## self.H = np.dstack([H1,H2]).copy()
FFT_img = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
#print "imgF:",FFT_img.shape,"filterF:",self.H.shape
C = cv2.mulSpectrums(FFT_img, self.H, 0, conjB=True)
resp = cv2.idft(C, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
h, w = resp.shape
#print "resp shape:",resp.shape
_, mval, _, (mx, my) = cv2.minMaxLoc(resp)
side_resp = resp.copy()
cv2.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1)
smean, sstd = side_resp.mean(), side_resp.std()
psr = (mval-smean) / (sstd+eps)
return resp, (mx-w//2, my-h//2), psr
def correlate(self, img):
# Multiply the image with the filter (in frequency space)
C = cv2.mulSpectrums(cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT), self.H, 0, conjB=True)
# Convert back to RGB space
resp = cv2.idft(C, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
# Look for peak
h, w = resp.shape
_, mval, _, (mx, my) = cv2.minMaxLoc(resp)
# Get the isolated peak response (should be a Gaussian point)
side_resp = resp.copy()
cv2.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1)
# Calculate the match probability
smean, sstd = side_resp.mean(), side_resp.std()
psr = (mval-smean) / (sstd+eps)
return resp, (mx-w//2, my-h//2), psr
def update(_):
ang = np.deg2rad( cv2.getTrackbarPos('angle', win) )
d = cv2.getTrackbarPos('d', win)
noise = 10**(-0.1*cv2.getTrackbarPos('SNR (db)', win))
if defocus:
psf = defocus_kernel(d)
else:
psf = motion_kernel(ang, d)
cv2.imshow('psf', psf)
psf /= psf.sum()
psf_pad = np.zeros_like(img)
kh, kw = psf.shape
psf_pad[:kh, :kw] = psf
PSF = cv2.dft(psf_pad, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows = kh)
PSF2 = (PSF**2).sum(-1)
iPSF = PSF / (PSF2 + noise)[...,np.newaxis]
RES = cv2.mulSpectrums(IMG, iPSF, 0)
res = cv2.idft(RES, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT )
res = np.roll(res, -kh//2, 0)
res = np.roll(res, -kw//2, 1)
cv2.imshow(win, res)
def externalCall(self):
image = self.inputImageName.data
imagef = np.float32(image)/255.0
d = 60
noise = 10**(-0.1*5)
psf = self.defocus_kernel(d, 100)
cv2.imshow('psf', psf)
#cv2.imshow('spektralblur',spektralblur)
bluredge = self.blur_edge(imagef)
se = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7,7))
bluredge = cv2.erode(bluredge, se)
dftimg = cv2.dft(bluredge, flags=cv2.DFT_COMPLEX_OUTPUT)
#----
psf /= psf.sum()
psf_pad = np.zeros_like(bluredge)
kh, kw = psf.shape
psf_pad[:kh, :kw] = psf
PSF = cv2.dft(psf_pad, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows=kh)
PSF2 = (PSF**2).sum(-1)
iPSF = PSF / (PSF2 + noise)[..., np.newaxis]
RES = cv2.mulSpectrums(dftimg, iPSF, 0)
deconvolve = cv2.idft(RES, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT )
deconvolve = np.roll(deconvolve, -kh//2, 0)
deconvolve = np.roll(deconvolve, -kw//2, 1)
self.outputImageName.data = deconvolve
def update(self, frame, lk_info):
#print "update entered"
lk_centre,lk_ratio = lk_info
(x, y), (w, h) = self.pos, self.size
ratio = sum(lk_ratio)/2.0
w = int(w*ratio)
h = int(h*ratio)
if w>max_ratio*self.org_size[0]:
w=int(max_ratio*self.org_size[0])
if h>max_ratio*self.org_size[1]:
h=int(max_ratio*self.org_size[1])
if w<min_ratio*self.org_size[0]:
w=int(min_ratio*self.org_size[0])
if h<min_ratio*self.org_size[1]:
h=int(min_ratio*self.org_size[1])
self.size = (w,h)
self.last_img = img = cv2.getRectSubPix(frame, self.size, (x, y))
frameVis = frame.copy()
img = self.preprocess(img,self.size)
self.last_resp, (dx, dy), self.psr = self.correlate(img,self.size)
self.good = self.psr > 8.0
######## particle filter implementation #########################
self.PF_number = int(max_particles*np.arctan(3-self.psr/4)/np.pi+max_particles/2+min_particles)
self.f = np.array([])
if(self.PF_number > self.prev_PF_count):
new_pts = np.ones((self.PF_number-self.prev_PF_count, 2), int) * self.pos
self.pt = np.vstack([self.pt,new_pts])
elif(self.PF_number < self.prev_PF_count):
temp_pts = self.pt.tolist()
n_pop = self.prev_PF_count - self.PF_number
for i in range(n_pop):
temp_pts.pop()
self.pt = np.asarray(temp_pts)
else:
pass
self.pt += np.random.uniform(-stepsize_PF, stepsize_PF, self.pt.shape)
self.pt = self.pt.clip(np.zeros(2), np.array(frame.shape)-1).astype(int)
PF_good = sum(self.pt.std(axis = 0)<PF_std)>0
#print PF_good
#print self.pt.std(axis = 0)
for i,point in enumerate(self.pt):
co_xy = tuple(point)
self.last_img_PF = img_PF = cv2.getRectSubPix(frame,self.size, co_xy)
img_PF = self.preprocess(img_PF,self.size)
last_resp_PF, (dx_PF, dy_PF), PF_PSR = self.correlate(img_PF,self.size)
good_PF = PF_PSR > 8.0
#self.f[i] = PF_PSR
self.f = np.append(self.f,PF_PSR)
cv2.circle(frameVis, co_xy, 1, 255, -1)
self.f0 = np.ones(self.PF_number)*psr_PF
## atan(x-8)/pi+1/2
##weights = 1./(1. + (self.f0-self.f)**2)
weights = (np.arctan(wt_param*(self.f-self.f0))/np.pi)+0.5
weights /= sum(weights)
new_co_xy = np.sum(self.pt.T*weights, axis=1)
new_co_xy = tuple(new_co_xy.astype(np.int))
cv2.circle(frameVis,new_co_xy,3,255,-1)
cv2.imshow('test',frameVis)
if 1./sum(weights**2) < n_PF/2.:
self.pt = self.pt[resample(weights),:]
self.prev_PF_count = self.PF_number
bbc.lk_ready = True
bbc.restartingLK = True
if not self.good:
if PF_good and PF_ON:
print "using PF"
self.pos = new_co_xy
else:
return
else:
self.pos = x+dx, y+dy
## if not self.good:
## self.pos = lk_centre
## self.last_img = img = cv2.getRectSubPix(frame, self.size, self.pos)
## img = self.preprocess(img,self.size)
## self.last_resp, (dxxx, dyyy), self.psr = self.correlate(img,self.size)
## self.good = self.psr > 8.0
##
## if not self.good:
## return
## else:
## self.using_lk = True
##
## if not self.using_lk:
## self.pos = (x+dx, y+dy)
self.last_img = img = cv2.getRectSubPix(frame, self.size, self.pos)
img = self.preprocess(img,self.size)
#print "img shape:",img.shape
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
g = np.zeros((h, w), np.float32)
g[h//2, w//2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums( A, A, 0, conjB=True)
self.H1 = self.resizeFFT(self.H1,self.size)
self.H2 = self.resizeFFT(self.H2,self.size)
self.H1 = self.H1 * (1.0-rate) + H1 * rate
self.H2 = self.H2 * (1.0-rate) + H2 * rate
self.update_kernel()
def shc_opencv(d0,d1):
'''
Read DocString for SHC
'''
d0 = np.float32(d0 - d0.mean())
d1 = np.float32(d1 - d1.mean())
if d0.shape != d1.shape:
raise ValueError("Input shapes do not match")
if d0.ndim > 2:
raise ValueError("Only 1-d or 2-d data supported")
## one dimensional case
if d0.ndim == 1:
## Manually Pad Arrays for DFT Optimization
rows = (d0.shape)[0]
nrows = cv2.getOptimalDFTSize(rows)
d0n = np.zeros((nrows))
d1n = np.zeros((nrows))
d0n[:rows] = d0
d1n[:rows] = d1
## Fourier Phase Correlation
d0_dft = cv2.dft(d0, flags = cv2.DFT_COMPLEX_OUTPUT)
d1_dft = cv2.dft(d1, flags = cv2.DFT_COMPLEX_OUTPUT)
d01 = cv2.mulSpectrums(d0_dft,d1_dft,flags = 0, conjB = True)
id01 = cv2.idft(d01, flags = cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
cc = np.fft.fftshift(np.abs(id01))
xmax = cc.argmax()
## Polyfit of degree 2 for three points, extremum
c1 = (cc[xmax+1]-cc[xmax-1])/2.
c2 = cc[xmax+1]-c1-cc[xmax]
xmax = xmax - c1/c2/2.
return xmax - d0.shape[0]/2
## two dimensional case
if d0.ndim == 2:
## Manually Pad Arrays for DFT Optimization
rows, cols = d0.shape
nrows = cv2.getOptimalDFTSize(rows)
ncols = cv2.getOptimalDFTSize(cols)
d0n = np.zeros((nrows,ncols))
d1n = np.zeros((nrows,ncols))
d0n[:rows,:cols] = d0
d1n[:rows,:cols] = d1
## Fourier Phase Correlation
d0_dft = cv2.dft(np.float32(d0n), flags = cv2.DFT_COMPLEX_OUTPUT)
d1_dft = cv2.dft(np.float32(d1n), flags = cv2.DFT_COMPLEX_OUTPUT)
d01 = cv2.mulSpectrums(d0_dft,d1_dft,flags = 0, conjB = True)
id01 = cv2.idft(d01, flags = cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT)
cc = np.fft.fftshift(np.abs(id01))
indices = np.where(cc == cc.max())
rmax = (indices[0])[0]
cmax = (indices[1])[0]
## Interpolate to sub-pixel accuracy
if (rmax*cmax >= 0) and (rmax < d0n.shape[0]) and (cmax < d0n.shape[1]):
## interpolate to sub-pixel accuracy
## we use a quadratic estimator as in Tian and Huhns (1986) pg 222
denom = 2.*(2.*cc.max() - cc[rmax+1,cmax] - cc[rmax-1, cmax])
rfra = (rmax) + (cc[rmax+1,cmax] -cc[rmax-1,cmax])/denom
denom = 2.*(2.*cc.max() - cc[rmax,cmax+1] - cc[rmax, cmax-1])
cfra = (cmax) + (cc[rmax,cmax+1] -cc[rmax,cmax-1])/denom
rmax = rfra
cmax = cfra
return np.array([rmax - d0n.shape[0]/2. , cmax - d0n.shape[1]/2.])
def convolveWithDFT(a, b, verbose=False):
'''
Returns a convolved with b. Uses DFT and Convolution Theorem.
:type a: numpy.ndarray
:type b: numpy.ndarray
:rtype: numpy.ndarray
'''
if verbose:
pbar = progressbar.ProgressBar(widgets=[progressbar.Percentage(), progressbar.Bar()], maxval=4).start()
# Based on: docs.opencv.org/modules/core/doc/operations_on_arrays.html#dft
# Create result and work out correct size.
a_rows, a_cols = a.shape
b_rows, b_cols = b.shape
result = np.empty((abs(a_rows-b_rows)+1, abs(a_cols-b_cols)+1))
# Calculate size for DFT
dft_width = cv2.getOptimalDFTSize((a_cols-b_cols)+1)
dft_height = cv2.getOptimalDFTSize((a_rows-b_rows)+1)
# Tranform a and b to fourier domain.
# Complexity: O(n**2 * log2(n)
# Create temporary buffers.
temp_a = np.zeros((dft_height, dft_width))
temp_b = np.zeros((dft_height, dft_width))
# Copy a and b to top left conerns of temporary buffers.
temp_a[0:a_cols, 0:a_rows] = a
temp_b[0:b_cols, 0:b_rows] = b
# Transform padded a&b in place.
# Use nonzeroRows hint for faster processing.
cv2.dft(temp_a, temp_a, 0, a_rows)
if verbose:
pbar.update(1)
cv2.dft(temp_b, temp_b, 0, b_rows)
if verbose:
pbar.update(2)
# By convolution theorem multiplication in fourier domain is equivalent to convolution
# in original domain.
# Perform per element multiplication.
# Complexity: O(n**2)
temp_a = cv2.mulSpectrums(temp_a, temp_b, False)
if verbose:
pbar.update(3)
# Transform result from fourier domain to original domain.
# Only need first abs(image_rows-kernel_rows)+1 rows of result.
# Complexity: O(n**2 * log2(n)
cv2.dft(temp_a, temp_a, cv2.DFT_INVERSE + cv2.DFT_SCALE, result.shape[1])
result = temp_a[0:result.shape[0], 0:result.shape[1]]
if verbose:
pbar.finish()
return result
def update(self, frame, rate = 0.125):
(x, y), (w, h) = self.pos, self.size
self.last_img = img = cv2.getRectSubPix(frame, (w, h), (x, y))
img = self.preprocess(img)
frameVis = frame.copy()
self.last_resp, (dx, dy), self.psr = self.correlate(img)
self.good = self.psr > 8.0
######## particle filter implementation #########################
self.PF_number = int(50*np.arctan(3-self.psr/4)/np.pi+30)
self.f = np.array([])
if(self.PF_number > self.prev_PF_count):
new_pts = np.ones((self.PF_number-self.prev_PF_count, 2), int) * self.pos
self.pt = np.vstack([self.pt,new_pts])
elif(self.PF_number < self.prev_PF_count):
temp_pts = self.pt.tolist()
n_pop = self.prev_PF_count - self.PF_number
for i in range(n_pop):
temp_pts.pop()
self.pt = np.asarray(temp_pts)
else:
pass
self.pt += np.random.uniform(-stepsize_PF, stepsize_PF, self.pt.shape)
self.pt = self.pt.clip(np.zeros(2), np.array(frame.shape)-1).astype(int)
PF_good = sum(self.pt.std(axis = 0)<PF_std)>0
#print PF_good
#print self.pt.std(axis = 0)
for i,point in enumerate(self.pt):
co_xy = tuple(point)
self.last_img_PF = img_PF = cv2.getRectSubPix(frame, (w, h), co_xy)
img_PF = self.preprocess(img_PF)
last_resp_PF, (dx_PF, dy_PF), PF_PSR = self.correlate(img_PF)
good_PF = PF_PSR > 8.0
#self.f[i] = PF_PSR
self.f = np.append(self.f,PF_PSR)
cv2.circle(frameVis, co_xy, 1, 255, -1)
## atan(x-8)/pi+1/2
#weights = 1./(1. + (self.f0-self.f)**2)
self.f0 = np.ones(self.PF_number)*psr_PF
#print self.f.shape,self.f0.shape
weights = (np.arctan(wt_param*(self.f-self.f0))/np.pi)+0.5
weights /= sum(weights)
new_co_xy = np.sum(self.pt.T*weights, axis=1)
new_co_xy = tuple(new_co_xy.astype(np.int))
cv2.circle(frameVis,new_co_xy,3,255,-1)
cv2.imshow('test',frameVis)
if 1./sum(weights**2) < n_PF/2.:
self.pt = self.pt[resample(weights),:]
self.prev_PF_count = self.PF_number
if not self.good:
if PF_good and PF_ON:
print "using PF"
self.pos = new_co_xy
else:
return
else:
self.pos = x+dx, y+dy
self.last_img = img = cv2.getRectSubPix(frame, (w, h), self.pos)
img = self.preprocess(img)
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums( A, A, 0, conjB=True)
self.H1 = self.H1 * (1.0-rate) + H1 * rate
self.H2 = self.H2 * (1.0-rate) + H2 * rate
self.update_kernel()
'''
fn = '../deblurring/2.png'
ang=0
d=27.3
noise=0.0001
#Calculation
ang=np.deg2rad(ang)
img = cv2.imread(fn, 0)
img = np.float32(img)/255.0
cv2.imshow('input', img)
IMG = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
psf = motion_kernel(ang, d)
#cv2.imshow('psf', psf)
psf /= psf.sum()
psf_pad = np.zeros_like(img)
kh, kw = psf.shape
psf_pad[:kh, :kw] = psf
PSF = cv2.dft(psf_pad, flags=cv2.DFT_COMPLEX_OUTPUT, nonzeroRows = kh)
PSF2 = (PSF**2).sum(-1)
iPSF = PSF / (PSF2 + noise)[...,np.newaxis]
RES = cv2.mulSpectrums(IMG, iPSF, 0)
res = cv2.idft(RES, flags=cv2.DFT_SCALE | cv2.DFT_REAL_OUTPUT )
res = np.roll(res, -kh//2, 0)
res = np.roll(res, -kw//2, 1)
#Result
cv2.imshow('Output',res)
cv2.waitKey(0)
cv2.destroyAllWindows()
def convolute(spec1, spec2):
flags = cv2.DFT_COMPLEX_OUTPUT | cv2.DFT_SCALE
return cv2.mulSpectrums(spec1, spec2, flags=flags)
def update(self, frame, lk_info):
#print "update entered"
lk_centre, lk_wh, lk_angle,lk_ratio = lk_info
(x, y), (w, h) = self.pos, self.size
## (x, y), (w, h) = lk_centre, self.size
w = int(w*lk_ratio[0])
h = int(h*lk_ratio[1])
if w>max_ratio*self.org_size[0]:
w=int(max_ratio*self.org_size[0])
if h>max_ratio*self.org_size[1]:
h=int(max_ratio*self.org_size[1])
if w<min_ratio*self.org_size[0]:
w=int(min_ratio*self.org_size[0])
if h<0.5*self.org_size[1]:
h=int(0.5*self.org_size[1])
self.size = (w,h)
self.last_img = img = cv2.getRectSubPix(frame, self.size, (x, y))
frameVis = frame.copy()
cv2.rectangle(frameVis, (int(x-w/2), int(y-h/2)), (int(x+w/2), int(y+h/2)), 255)
img = self.preprocess(img,self.size)
self.last_resp, (dx, dy), self.psr = self.correlate(img,self.size)
self.good = self.psr > PSR_mosse
if not self.good:
## theta = np.arctan2(dy,dx)
## for i in range(-5,6):
## self.tx,self.ty = (2.0*x+dx)/2.0 + r*np.cos(theta+i*delta),(2.0*y+dy)/2.0 + r*np.sin(theta+i*delta)
##
## cv2.rectangle(frameVis, (int(self.tx-w/2),int(self.ty-h/2)), (int(self.tx+w/2),int(self.ty+h/2)), 255)
## cv2.circle(frameVis, (int(self.tx), int(self.ty)), 2, 255, -1)
##
## self.last_img = img = cv2.getRectSubPix(frame, self.size, (self.tx, self.ty))
## img = self.preprocess(img,self.size)
## self.last_resp, (dx, dy), self.psr = self.correlate(img,self.size)
## self.good = self.psr>PSR_local
## cv2.imshow('test',frameVis)
## if self.good:
## self.ImpUsed = True
## print 'i :',i
## break
if not self.ImpUsed:
self.pos = lk_centre
self.last_img = img = cv2.getRectSubPix(frame, self.size, self.pos)
img = self.preprocess(img,self.size)
self.last_resp, (dx, dy), self.psr = self.correlate(img,self.size)
self.good = self.psr > PSR_lk
if not self.good:
return
else:
self.using_lk = True
if self.ImpUsed:
self.pos = self.tx,self.ty
self.ImpUsed = False
if not self.using_lk:
self.pos = x+dx, y+dy
self.last_img = img = cv2.getRectSubPix(frame, self.size, self.pos)
img = self.preprocess(img,self.size)
#print "img shape:",img.shape
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
g = np.zeros((h, w), np.float32)
g[h//2, w//2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums( A, A, 0, conjB=True)
self.H1 = self.resizeFFT(self.H1,self.size)
self.H2 = self.resizeFFT(self.H2,self.size)
self.H1 = self.H1 * (1.0-rate) + H1 * rate
self.H2 = self.H2 * (1.0-rate) + H2 * rate
self.update_kernel()
def update(self, frame, lk_info, rate = 0.125):
#print "update entered"
lk_centre, lk_wh, lk_angle,lk_ratio = lk_info
(x, y), (w, h) = self.pos, self.size
w = int(w*lk_ratio[0])
h = int(h*lk_ratio[1])
if w>2*self.org_size[0]:
w=int(2*self.org_size[0])
if h>2*self.org_size[1]:
h=int(2*self.org_size[1])
if w<0.5*self.org_size[0]:
w=int(0.5*self.org_size[0])
if h<0.5*self.org_size[1]:
h=int(0.5*self.org_size[1])
self.size = (w,h)
self.last_img = img = cv2.getRectSubPix(frame, self.size, (x, y))
img = self.preprocess(img,self.size)
self.last_resp, (dx, dy), self.psr = self.correlate(img,self.size)
self.good = self.psr > 9.0
if not self.good:
self.pos = lk_centre
self.last_img = img = cv2.getRectSubPix(frame, self.size, self.pos)
img = self.preprocess(img,self.size)
self.last_resp, (dx, dy), self.psr = self.correlate(img,self.size)
self.good = self.psr > 8.0
if not self.good:
return
else:
print "using lk"
self.using_lk = True
if not self.using_lk:
self.pos = x+dx, y+dy
self.last_img = img = cv2.getRectSubPix(frame, self.size, self.pos)
img = self.preprocess(img,self.size)
#print "img shape:",img.shape
A = cv2.dft(img, flags=cv2.DFT_COMPLEX_OUTPUT)
g = np.zeros((h, w), np.float32)
g[h//2, w//2] = 1
g = cv2.GaussianBlur(g, (-1, -1), 2.0)
g /= g.max()
self.G = cv2.dft(g, flags=cv2.DFT_COMPLEX_OUTPUT)
H1 = cv2.mulSpectrums(self.G, A, 0, conjB=True)
H2 = cv2.mulSpectrums( A, A, 0, conjB=True)
self.H1 = self.resizeFFT(self.H1,self.size)
self.H2 = self.resizeFFT(self.H2,self.size)
self.H1 = self.H1 * (1.0-rate) + H1 * rate
self.H2 = self.H2 * (1.0-rate) + H2 * rate
self.update_kernel()