def _opticalFlow(self):
'''
Compute the optical flow between frames using cv.CalcOpticalFlow
@returns: a list of tracks for the new image
@rtype: list of pv.Point()
'''
flags = 0
grey = self.frame
prev_grey = self.prev_frame
pyramid = cv.CreateImage (cv.GetSize (grey), 8, 1)
prev_pyramid = cv.CreateImage (cv.GetSize (grey), 8, 1)
cv_points = []
for each in self.tracks:
cv_points.append((each.X(),each.Y()))
points_b, _, _,= cv.CalcOpticalFlowPyrLK (
prev_grey,
grey,
prev_pyramid,
pyramid,
cv_points,
(5,5),
3,#pyr number
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 10, 0.01),
flags)
result = []
for pt in points_b:
result.append(pv.Point(pt))
return result
def OpticalFlowForOrientation(imagenew,imageold,gfttar,weights=0,existence=0):
pyrold = cv.CreateImage((imagenew.width,imagenew.height),
cv.IPL_DEPTH_32F,
1)
pyrnew = cv.CreateImage((imagenew.width,imagenew.height),
cv.IPL_DEPTH_32F,
1)
(gfttarnew,status,track_error)= cv.CalcOpticalFlowPyrLK(imageold,
imagenew,
pyrold,
pyrnew,
gfttar,
(10,10),
5,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS,20,0.03),
0)
for i in range (0,len(status)):
if status[i] == 0:
gfttar.pop(i)
gfttarnew.pop(i)
return gfttarnew, gfttar
def OpticalFlow(imagenew, imageold, gfttar, weights=0, existence=0):
pyrold = cv.CreateImage((imagenew.width, imagenew.height),
cv.IPL_DEPTH_32F, 1)
pyrnew = cv.CreateImage((imagenew.width, imagenew.height),
cv.IPL_DEPTH_32F, 1)
(gfttarnew, status, track_error) = cv.CalcOpticalFlowPyrLK(
imageold, imagenew, pyrold, pyrnew, gfttar, (10, 10), 5,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03), 0)
#UpdatePointWeights(list_gftt_new,list_gftt)
#DropPoints(gf
return gfttarnew, weights, existence
def lucas_kanade(img1,
img2,
corners1,
win=WIN,
num_pyramids=PYRAMIDS,
criteria=FLOW_CRITERIA,
flags=FLAGS):
pyr_size = (img1.width + 8, img2.height / 3
) # magic formula provided by openCV
pyr1 = cv.CreateImage(pyr_size, cv.IPL_DEPTH_32F, 1)
pyr2 = cv.CreateImage(pyr_size, cv.IPL_DEPTH_32F, 1)
return cv.CalcOpticalFlowPyrLK(img1, img2, pyr1, pyr2, corners1, win,
num_pyramids, criteria, flags)
def verify_still_tracking(self):
self.detected = 2
# compute optical flow
self.features, status, track_error = cv.CalcOpticalFlowPyrLK(
self.prev_grey, self.grey, self.prev_pyramid, self.pyramid,
self.features, (self.win_size, self.win_size), 3,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03), self.flags)
# set back the points we keep
self.features = [p for (st, p) in zip(status, self.features) if st]
if len(self.features) < 4:
self.tracking = False # we lost it, restart search
log.info("tracking -> not tracking: len features %d < 4" %
len(self.features))
else:
# make sure that in addition the distances are consistent
ds1 = ptdst(self.features[0], self.features[1])
ds2 = ptdst(self.features[2], self.features[3])
if max(ds1, ds2) / min(ds1, ds2) > 1.4:
self.tracking = False
log.info(
"tracking -> not tracking: max/min ds1 %s, ds2 %s > 1.4" %
(ds1, ds2))
ds3 = ptdst(self.features[0], self.features[2])
ds4 = ptdst(self.features[1], self.features[3])
if max(ds3, ds4) / min(ds3, ds4) > 1.4:
self.tracking = False
log.info(
"tracking -> not tracking: max/min ds3 %s, ds4 %s > 1.4" %
(ds3, ds4))
if ds1 < 10 or ds2 < 10 or ds3 < 10 or ds4 < 10:
self.tracking = False
log.info(
"tracking -> not tracking: ds1 %s, ds2 %s, ds3 %s, ds4 %s"
% (ds1, ds2, ds3, ds4))
if not self.tracking:
self.detected = 0
#features = []
#for i in range(1, dst_img.width, 1):
# for j in range(1, dst_img.height, 1):
# features.append((i,j))
#cornerMap = cv.CreateMat(src_im1.height, src_im1.width, cv.CV_32FC1)
#cv.CornerHarris(src_im1,cornerMap,3)
#features = []
#for y in range(0, src_im1.height):
# for x in range(0, src_im1.width):
# harris = cv.Get2D(cornerMap, y, x)
# if harris[0] > 10e-6:
# features.append((x, y))
r = cv.CalcOpticalFlowPyrLK(
src_im1, src_im2, None, None, features, (50, 50), 0,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 64, 0.01), 0)
list = r[0]
for i in range(len(list)):
dis = math.sqrt(
math.pow((features[i][0] - list[i][0]), 2) +
math.pow((features[i][1] - list[i][1]), 2))
cv.Line(dst_img, (int(features[i][0]), int(features[i][1])),
(int(list[i][0]), int(list[i][1])), cv.CV_RGB(255, 0, 0), 1,
cv.CV_AA, 0)
cv.NamedWindow("w", cv.CV_WINDOW_AUTOSIZE)
cv.ShowImage("w", dst_img)
cv.WaitKey()
def track_lk(self, cv_image, face):
feature_box = None
""" Initialize intermediate images if necessary """
if not face.pyramid:
face.grey = cv.CreateImage(cv.GetSize(cv_image), 8, 1)
face.prev_grey = cv.CreateImage(cv.GetSize(cv_image), 8, 1)
face.pyramid = cv.CreateImage(cv.GetSize(cv_image), 8, 1)
face.prev_pyramid = cv.CreateImage(cv.GetSize(cv_image), 8, 1)
face.features = []
""" Create a grey version of the image """
cv.CvtColor(cv_image, face.grey, cv.CV_BGR2GRAY)
""" Equalize the histogram to reduce lighting effects """
cv.EqualizeHist(face.grey, face.grey)
if face.track_box and face.features != []:
""" We have feature points, so track and display them """
""" Calculate the optical flow """
face.features, status, track_error = cv.CalcOpticalFlowPyrLK(
face.prev_grey, face.grey, face.prev_pyramid, face.pyramid,
face.features, (self.win_size, self.win_size), 3,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.01),
self.flags)
""" Keep only high status points """
face.features = [p for (st, p) in zip(status, face.features) if st]
elif face.track_box and self.is_rect_nonzero(face.track_box):
""" Get the initial features to track """
""" Create a mask image to be used to select the tracked points """
mask = cv.CreateImage(cv.GetSize(cv_image), 8, 1)
""" Begin with all black pixels """
cv.Zero(mask)
""" Get the coordinates and dimensions of the track box """
try:
x, y, w, h = face.track_box
except:
return None
if self.auto_face_tracking:
# """ For faces, the detect box tends to extend beyond the actual object so shrink it slightly """
# x = int(0.97 * x)
# y = int(0.97 * y)
# w = int(1 * w)
# h = int(1 * h)
""" Get the center of the track box (type CvRect) so we can create the
equivalent CvBox2D (rotated rectangle) required by EllipseBox below. """
center_x = int(x + w / 2)
center_y = int(y + h / 2)
roi_box = ((center_x, center_y), (w, h), 0)
""" Create a filled white ellipse within the track_box to define the ROI. """
cv.EllipseBox(mask, roi_box, cv.CV_RGB(255, 255, 255),
cv.CV_FILLED)
else:
""" For manually selected regions, just use a rectangle """
pt1 = (x, y)
pt2 = (x + w, y + h)
cv.Rectangle(mask, pt1, pt2, cv.CV_RGB(255, 255, 255),
cv.CV_FILLED)
""" Create the temporary scratchpad images """
eig = cv.CreateImage(cv.GetSize(self.grey), 32, 1)
temp = cv.CreateImage(cv.GetSize(self.grey), 32, 1)
if self.feature_type == 0:
""" Find keypoints to track using Good Features to Track """
face.features = cv.GoodFeaturesToTrack(
face.grey,
eig,
temp,
self.max_count,
self.quality,
self.good_feature_distance,
mask=mask,
blockSize=self.block_size,
useHarris=self.use_harris,
k=0.04)
elif self.feature_type == 1:
""" Get the new features using SURF """
(surf_features, descriptors) = cv.ExtractSURF(
face.grey, mask, cv.CreateMemStorage(0),
(0, self.surf_hessian_quality, 3, 1))
for feature in surf_features:
face.features.append(feature[0])
#
if self.auto_min_features:
""" Since the detect box is larger than the actual face
or desired patch, shrink the number of features by 10% """
face.min_features = int(len(face.features) * 0.9)
face.abs_min_features = int(0.5 * face.min_features)
""" Swapping the images """
face.prev_grey, face.grey = face.grey, face.prev_grey
face.prev_pyramid, face.pyramid = face.pyramid, face.prev_pyramid
""" If we have some features... """
if len(face.features) > 0:
""" The FitEllipse2 function below requires us to convert the feature array
into a CvMat matrix """
try:
self.feature_matrix = cv.CreateMat(1, len(face.features),
cv.CV_32SC2)
except:
pass
""" Draw the points as green circles and add them to the features matrix """
i = 0
for the_point in face.features:
if self.show_features:
cv.Circle(self.marker_image,
(int(the_point[0]), int(the_point[1])), 2,
(0, 255, 0, 0), cv.CV_FILLED, 8, 0)
try:
cv.Set2D(self.feature_matrix, 0, i,
(int(the_point[0]), int(the_point[1])))
except:
pass
i = i + 1
""" Draw the best fit ellipse around the feature points """
if len(face.features) > 6:
feature_box = cv.FitEllipse2(self.feature_matrix)
else:
feature_box = None
""" Publish the ROI for the tracked object """
# try:
# (roi_center, roi_size, roi_angle) = feature_box
# except:
# logger.info("Patch box has shrunk to zeros...")
# feature_box = None
# if feature_box and not self.drag_start and self.is_rect_nonzero(face.track_box):
# self.ROI = RegionOfInterest()
# self.ROI.x_offset = min(self.image_size[0], max(0, int(roi_center[0] - roi_size[0] / 2)))
# self.ROI.y_offset = min(self.image_size[1], max(0, int(roi_center[1] - roi_size[1] / 2)))
# self.ROI.width = min(self.image_size[0], int(roi_size[0]))
# self.ROI.height = min(self.image_size[1], int(roi_size[1]))
# self.pubROI.publish(self.ROI)
if feature_box is not None and len(face.features) > 0:
return feature_box
else:
return None
cv.ShowImage(window1, gray_image)
else:
cv.ShowImage(window1, render_image)
#Image processing
cv.CvtColor(img, gray_image, cv.CV_RGB2GRAY)
cv.Copy(gray_image, register1_image)
cv.Smooth(register1_image, register1_image, cv.CV_GAUSSIAN, 3, 3)
cv.AbsDiff(register1_image, register2_image, accumulator)
cv.InRangeS(accumulator, (threshold_limit1_lower), (threshold_limit1_upper), accumulator)
cv.Dilate(accumulator, accumulator, None, 2)
cv.Add(accumulator, sum_image, sum_image, accumulator)
cv.SubS(sum_image, (fading_factor), sum_image)
cv.InRangeS(sum_image, (threshold_limit2_lower), (threshold_limit2_upper), accumulator)
cv.Copy(register1_image, register2_image)
#Motion detection
new_corners, status, track_error = cv.CalcOpticalFlowPyrLK(prev_image, gray_image, pyramid1, pyramid2, corners, (10,10), 2, (cv.CV_TERMCRIT_ITER, 10, 0), 0)
counter = (counter + 1) % skip
if(counter == 0):
corners = cv.GoodFeaturesToTrack(gray_image, eigen_image, temp_image, cornerCount = corner_count, qualityLevel = quality, minDistance = min_distance) #Good features to track
flag = True
cv.Copy(img, render_image)
cv.CvtColor(accumulator, render_image, cv.CV_GRAY2RGB)
#cv.Copy(img, render_image)
cv.Copy(gray_image, prev_image)
#Drawing vectors and averaging the rotation...
sum = 0
summing_counter = 0
if flag:
flag = not flag
else:
for i in range(len(new_corners)):
quality, min_distance, None, 3,
0, 0.04)
# refine the corner locations
features = cv.FindCornerSubPix(
grey, features, (win_size, win_size), (-1, -1),
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03))
elif features != []:
# we have points, so display them
# cv.ShowImage ('prev_grey', prev_grey)
# cv.ShowImage ('grey', grey)
# calculate the optical flow
features, status, track_error = cv.CalcOpticalFlowPyrLK(
prev_grey, grey, prev_pyramid, pyramid, features,
(win_size, win_size), 3,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03), flags)
# print "num features: ", sum(status)
# print "status: ", status
# set back the points we keep
features = [p for (st, p) in zip(status, features) if st]
# count = 0;
# for feat in features:
# print "feature coordinates: ", feat, count
# count = count + 1
if add_remove_pt:
# we have a point to add, so see if it is close to
# another one. If yes, don't use it
def main():
path = "../rawData/outdoor1/GOPR0003_0/"
files = os.listdir(path)
"""
Get SIFT features for the first frame
"""
imname = path+files[10]
a = time()
sift.process_image(imname,'empire.sift')
l1,d1 = sift.read_features_from_file('empire.sift')
b = time()
print "Time for getting SIFT features: ",b - a
refine_l = []
""" define the bounding box and filter the points"""
b_ver1 = (60,91)
b_ver2 = (148,315)
w = (b_ver2[0] - b_ver1[0])
h = (b_ver2[1] - b_ver1[1])
initalIndicator = 1 #indicate the scale of the box
for i,p in enumerate(l1):
center = p[:2]
if center[0] > 60 and center[0] < 148 and center[1] > 91 and center[1] < 315:
refine_l.append(tuple(center))
color = (0,0,255)
""" start at frame285 """
startIndex = 10
#writer = cv.CreateVideoWriter("myTrack.avi",cv.CV_FOURCC('M','J','P','G'),60,cv.GetSize (cv.LoadImage(path+files[startIndex])),1)
while (startIndex<=2900):
frameStartTime = time()
seq = [cv.LoadImage(path+files[startIndex]),
cv.LoadImage(path+files[startIndex+1])]
"""
calculate optical flow
"""
newFrameImageGS_32F1 = cv.CreateImage (cv.GetSize (seq[0]), 8, 1)
newFrameImageGS_32F2 = cv.CreateImage (cv.GetSize (seq[0]), 8, 1)
cv.CvtColor(seq[0],newFrameImageGS_32F1,cv.CV_RGB2GRAY)
cv.CvtColor(seq[1],newFrameImageGS_32F2,cv.CV_RGB2GRAY)
pyramid = cv.CreateImage (cv.GetSize (seq[0]), 8, 1)
prev_pyramid = cv.CreateImage (cv.GetSize (seq[0]), 8, 1)
flags = 0
points, status1, errors,= cv.CalcOpticalFlowPyrLK (
newFrameImageGS_32F1,
newFrameImageGS_32F2,
prev_pyramid,
pyramid,
refine_l,
(10,10),
3,#pyr number
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 10, 0.01),
flags)
"""center of mass of points"""
p_x = 0.0
p_y = 0.0
sumWeight = 0.0
for i,point in enumerate(points):
myweight = windowWeight(point,b_ver1,b_ver2)
p_x += myweight*point[0]
p_y += myweight*point[1]
sumWeight += myweight
# p_x = [windowWeight(point,b_ver1,b_ver2)*point[0] for point in points]
# p_y = [windowWeight(point,b_ver1,b_ver2)*point[1] for point in points]
# weight = [windowWeight(point,b_ver1,b_ver2) for point in points]
cm_x = p_x/sumWeight
cm_y = p_y/sumWeight
""" remove far away points """
diag = mynorm(b_ver1,b_ver2)
points = [point for point in points if mynorm(point,(cm_x,cm_y)) <= 0.7*diag]
"""
detect scale change by finding the density of points
"""
densityIndicator = sum([mynorm(point,(cm_x,cm_y)) for point in points])/len(points)
if startIndex == 10:
initalIndicator = densityIndicator
#print "Scale indicator ", densityIndicator/initalIndicator
""" Calculate new bounding box """
new_w = w*densityIndicator/initalIndicator
new_h = h*densityIndicator/initalIndicator
b_ver1 = (int(cm_x-new_w/2), int(cm_y-new_h/2))
b_ver2 = (int(cm_x+new_w/2), int(cm_y+new_h/2))
frameEndTime = time()
print "Time to process one frame: ", frameEndTime - frameStartTime
""" draw images and detected points"""
for pt in refine_l:
cv.Circle(seq[0], (int(pt[0]), int(pt[1])), 5, color, 0, cv.CV_AA, 0)
cv.Circle(seq[0], (int(cm_x), int(cm_y)), 10, (0,255,255), 0, cv.CV_AA, 0)
cv.Rectangle(seq[0],b_ver1,b_ver2,(255,0,0))
cv.ShowImage('First', seq[0])
cv.WaitKey(30)
for pt in points:
cv.Circle(seq[1], (int(pt[0]), int(pt[1])), 5, color, 0, cv.CV_AA, 0)
cv.Circle(seq[1], (int(cm_x), int(cm_y)), 10, (0,255,255), 0, cv.CV_AA, 0)
cv.Rectangle(seq[1],b_ver1,b_ver2,(255,0,0))
cv.ShowImage('First', seq[1])
refine_l = points
startIndex += 1
def main():
path = "../rawData/outdoor1/GOPR0003_0/"
files = os.listdir(path)
"""
Get SIFT features for the first frame
"""
imname = path + files[10]
a = time()
sift.process_image(imname, 'empire.sift')
l1, d1 = sift.read_features_from_file('empire.sift')
b = time()
print "Time for getting SIFT features: ", b - a
refine_l = []
#figure()
#gray()
b_ver1 = (60, 91)
b_ver2 = (148, 315)
for i, p in enumerate(l1):
center = p[:2]
if i % 30 == 0:
# if center[0] < 60 or center[0] > 148:
# continue
# if center[1] < 91 or center[1] > 315:
# continue
refine_l.append(tuple(center))
# plot(center[0],center[1],'ob')
# imshow(im1)
# axis('off')
elif center[0] > 60 and center[0] < 148 and center[1] > 91 and center[
1] < 315:
refine_l.append(tuple(center))
#sift.plot_features(im1,l1,circle=True)
#show()
startIndex = 10
while (startIndex <= 90):
seq = [
cv.LoadImage(path + files[startIndex]),
cv.LoadImage(path + files[startIndex + 1])
]
#draw a box on image 1
# cv.Rectangle(seq[0],(60,91),(148,315),(255,0,0))
# cv.ShowImage('TestOpticFlow', seq[0])
#
# cv.WaitKey()
# cv.DestroyAllWindows()
"""
calculate optical flow
"""
color = (0, 0, 255)
newFrameImageGS_32F1 = cv.CreateImage(cv.GetSize(seq[0]), 8, 1)
newFrameImageGS_32F2 = cv.CreateImage(cv.GetSize(seq[0]), 8, 1)
cv.CvtColor(seq[0], newFrameImageGS_32F1, cv.CV_RGB2GRAY)
cv.CvtColor(seq[1], newFrameImageGS_32F2, cv.CV_RGB2GRAY)
pyramid = cv.CreateImage(cv.GetSize(seq[0]), 8, 1)
prev_pyramid = cv.CreateImage(cv.GetSize(seq[0]), 8, 1)
flags = 0
#a = time()
points, status, errors, = cv.CalcOpticalFlowPyrLK(
newFrameImageGS_32F1,
newFrameImageGS_32F2,
prev_pyramid,
pyramid,
refine_l,
(10, 10),
6, #pyr number
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 10, 0.01),
flags)
#b = time()
#print "Time for calculating optical flow: ",b - a
#a = time()
fp = make_homog(transpose(array(refine_l)))
tp = make_homog(transpose(array(points)))
H = H_from_points(fp, tp)
#H = Haffine_from_points(fp,tp)
#b = time()
#print "Time for calculating homography: ",b - a
#print H[0:2,0:2]
H_solve_s_and_ang(H[0:2, 0:2])
#print H[0:2,2]
disp = (int(H[0:2, 2][0]), int(H[0:2, 2][1]))
cv.Rectangle(seq[0], b_ver1, b_ver2, (255, 0, 0))
for pt in refine_l:
cv.Circle(seq[0], (int(pt[0]), int(pt[1])), 5, color, 0, cv.CV_AA,
0)
cv.ShowImage('First', seq[0])
cv.WaitKey(30)
b_ver1 = (b_ver1[0] + disp[0], b_ver1[1] + disp[1])
b_ver2 = (b_ver2[0] + disp[0], b_ver2[1] + disp[1])
cv.Rectangle(seq[1], b_ver1, b_ver2, (255, 0, 0))
#cv.DestroyWindow('First')
for pt in points:
cv.Circle(seq[1], (int(pt[0]), int(pt[1])), 5, color, 0, cv.CV_AA,
0)
cv.ShowImage('First', seq[1])
#sleep(0.7)
cv.WaitKey(5)
#cv.DestroyWindow('First')
startIndex += 1
def run(self):
image = None
MAX_COUNT = 500
win_size = (32, 32)
line_draw = 2
frame = cv.QueryFrame(self.capture)
image = cv.CreateImage(cv.GetSize(frame), 8, 3)
image.origin = frame.origin
grey = cv.CreateImage(cv.GetSize(frame), 8, 1)
edges = cv.CreateImage(cv.GetSize(frame), 8, 1)
prev_grey = cv.CreateImage(cv.GetSize(frame), 8, 1)
prev_grey2 = cv.CreateImage(cv.GetSize(frame), 8, 1)
prev_grey3 = cv.CreateImage(cv.GetSize(frame), 8, 1)
pyramid = cv.CreateImage(cv.GetSize(frame), 8, 1)
prev_pyramid = cv.CreateImage(cv.GetSize(frame), 8, 1)
points = []
prev_points = []
count = 0
criteria = (cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03)
while True:
frame = cv.QueryFrame(self.capture)
# cv.Rectangle( frame, self.last_rect[0], self.last_rect[1], cv.CV_RGB(255,0,0), 3, cv.CV_AA, 0 )
# cv.Smooth(frame, frame, cv.CV_GAUSSIAN, 15, 0)
cv.Copy(frame, image)
cv.CvtColor(image, grey, cv.CV_BGR2GRAY)
if count == 0:
eig = cv.CreateImage(cv.GetSize(grey), 32, 1)
temp = cv.CreateImage(cv.GetSize(grey), 32, 1)
quality = 0.01
min_distance = 10
points = cv.GoodFeaturesToTrack(grey, eig, temp, MAX_COUNT,
quality, min_distance, None, 3,
0, 0.04)
points = cv.FindCornerSubPix(grey, points, win_size, (-1, -1),
criteria)
else:
flags = 0
points, status, track_error = cv.CalcOpticalFlowPyrLK(
prev_grey, grey, prev_pyramid, pyramid, prev_points,
win_size, 2, criteria, flags)
diff_points = []
for i, j in enumerate(points):
print j
if not j == prev_points[i]:
diff_points.append(j)
print 'len %d' % len(diff_points)
prev_points == points
count = len(points)
print count
prev_grey = grey
prev_pyramid = pyramid
prev_points = points
if line_draw:
cv.Canny(grey, edges, 30, 150, 3)
if line_draw == 1:
cv.CvtColor(edges, image, cv.CV_GRAY2BGR)
elif line_draw > 1:
cv.Merge(edges, prev_grey2, prev_grey3, None, image)
cv.Copy(prev_grey2, prev_grey3, None)
cv.Copy(edges, prev_grey2, None)
cv.ShowImage("Target", image)
# Listen for ESC key
c = cv.WaitKey(7) % 0x100
if c == 27:
break
GAUSSIAN_BLUR_FACTOR)
cv.ConvertImage(thumbnail, frame2_1C, cv.CV_CVTIMG_FLIP)
t = Thread(target=motion_bbox, args=(
output,
motion,
))
t.run()
#obtencion de caracteristicas del primer frame
frame1_features = cv.GoodFeaturesToTrack(frame1_1C, eig_image, temp_image,
NFEATURES, 0.1, 5, None, 3, False)
#busqueda de caracteristicas del primer frame, en el segundo usando el algoritmo de Lucas Kanade
frame2_features, status, track_error = cv.CalcOpticalFlowPyrLK(
frame1_1C, frame2_1C, pyramid1, pyramid2, frame1_features, (3, 3), 5,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03), 0)
#recorrido de las caracteristicas y dibujo de las flechas
#utilizando el algoritmo de http://ai.stanford.edu/~dstavens/cs223b/optical_flow_demo.cpp
totals = []
for pt1, pt2 in bbox_list: #recorrido de los bounding box finales
cv.Rectangle(output, pt1, pt2, cv.CV_RGB(255, 0, 0),
1) #se dibuja un rectangulo en ese bounding box
center = (min(pt1[0], pt2[0]) + abs(pt1[0] - pt2[0]) / 2,
min(pt1[1], pt2[1]) + abs(pt1[1] - pt2[1]) / 2)
angles = []
for i in range(len(frame2_features)):
p = frame1_features[i]
q = frame2_features[i]
p = int(p[0]), int(p[1])
cv.CvtColor(aa, a, cv.CV_BGR2GRAY)
cv.CvtColor(bb, b, cv.CV_BGR2GRAY)
# map = cv.CreateMat(2, 3, cv.CV_32FC1)
# cv.GetRotationMatrix2D((256, 256), 10, 1.0, map)
# b = cv.CloneMat(a)
# cv.WarpAffine(a, b, map)
eig_image = cv.CreateMat(a.height, a.width, cv.CV_32FC1)
temp_image = cv.CreateMat(a.height, a.width, cv.CV_32FC1)
prevPyr = cv.CreateMat(a.height / 3, a.width + 8, cv.CV_8UC1)
currPyr = cv.CreateMat(a.height / 3, a.width + 8, cv.CV_8UC1)
prevFeatures = cv.GoodFeaturesToTrack(a, eig_image, temp_image, 400,
0.01, 0.01)
(currFeatures, status, track_error) = cv.CalcOpticalFlowPyrLK(
a, b, prevPyr, currPyr, prevFeatures, (10, 10), 3,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03), 0)
if 1: # enable visualization
print
print sum(status), "Points found in curr image"
for prev, this in zip(prevFeatures, currFeatures):
iprev = tuple([int(c) for c in prev])
ithis = tuple([int(c) for c in this])
cv.Circle(a, iprev, 3, 255)
cv.Circle(a, ithis, 3, 0)
cv.Line(a, iprev, ithis, 128)
snapL([a, b])
fc = (fc + 1) % len(frames)
#exit
