def getIndividualContoursRectangles(contours): #Return the bounding rect for every contours
contourscopy = contours
rectangleList = []
while contourscopy:
x,y,w,h = cv.BoundingRect(contourscopy)
rectangleList.append((x,y,w,h))
contourscopy = contourscopy.h_next()
return rectangleList
def motionDetect(self, img):
cv.Smooth(img, img, cv.CV_GAUSSIAN, 3, 0)
cv.RunningAvg(img, self.movingAvg, 0.020, None)
cv.ConvertScale(self.movingAvg, self.tmp, 1.0, 0.0)
cv.AbsDiff(img, self.tmp, self.diff)
cv.CvtColor(self.diff, self.grayImage, cv.CV_RGB2GRAY)
cv.Threshold(self.grayImage, self.grayImage, 70,255, cv.CV_THRESH_BINARY)
cv.Dilate(self.grayImage, self.grayImage, None, 18)#18
cv.Erode(self.grayImage, self.grayImage, None, 10)#10
storage = cv.CreateMemStorage(0)
contour = cv.FindContours(self.grayImage, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE)
# points = []
while contour:
boundRect = cv.BoundingRect(list(contour))
contour = contour.h_next()
pt1 = (boundRect[0], boundRect[1])
pt2 = (boundRect[0] + boundRect[2], boundRect[1] + boundRect[3])
cv.Rectangle(img, pt1, pt2, cv.CV_RGB(255,255,0), 1)
return img
cv.Erode(imgbluethresh, imgbluethresh, None, 3)
cv.Dilate(imgbluethresh, imgbluethresh, None, 10)
# ??
img2 = cv.CloneImage(imgbluethresh)
# ??
storage = cv.CreateMemStorage(0)
contour = cv.FindContours(imgbluethresh, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE)
# blank list into which points for bounding rectangles around blobs are appended
points = []
# this is the new part here. ie use of cv.BoundingRect()
while contour:
# Draw bounding rectangles
bound_rect = cv.BoundingRect(list(contour))
contour = contour.h_next()
#print contour # not sure why print contour
# for more details about cv.BoundingRect,see documentation
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3])
points.append(pt1)
points.append(pt2)
# UPDATED 9/22: CALCULATED X AND Y SIZES OF BOUNDING BOX
xpix = math.fabs(pt1[0] - pt2[0])
ypix = math.fabs(pt1[1] - pt2[1])
print('xpix:'+str(xpix))
print('ypix:'+str(ypix))
print('pt1:'+str(pt1[0]))
print('pt2:'+str(pt2[0]))
def procImg(img, sideName, dispFlag):
#creates empty images of the same size
imdraw = cv.CreateImage(cv.GetSize(img), 8, 3)
#put the smoothed image here
imgSmooth = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.SetZero(imdraw)
cv.Smooth(img, imgSmooth, cv.CV_GAUSSIAN, 3, 0) #Gaussian filter the image
imgbluethresh = getthresholdedimg(
imgSmooth) #Get a color thresholed binary image
cv.Erode(imgbluethresh, imgbluethresh, None, 3)
cv.Dilate(imgbluethresh, imgbluethresh, None, 10)
#img2 = cv.CloneImage(imgbluethresh)
storage = cv.CreateMemStorage(0)
contour = cv.FindContours(imgbluethresh, storage, cv.CV_RETR_CCOMP,
cv.CV_CHAIN_APPROX_SIMPLE)
centroidx = 0
centroidy = 0
prevArea = 0
pt1 = (0, 0)
pt2 = (0, 0)
while contour:
#find the area of each collection of contiguous points (contour)
bound_rect = cv.BoundingRect(list(contour))
contour = contour.h_next()
#get the largest contour
area = bound_rect[2] * bound_rect[3]
if dispFlag:
print("Area= " + str(area))
if (area > prevArea and area > 3000):
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2],
bound_rect[1] + bound_rect[3])
# Draw bounding rectangle
cv.Rectangle(img, pt1, pt2, cv.CV_RGB(255, 0, 0), 3)
# calculating centroid
centroidx = cv.Round((pt1[0] + pt2[0]) / 2)
centroidy = cv.Round((pt1[1] + pt2[1]) / 2)
if (centroidx == 0 or centroidy == 0):
print("no blimp detected from " + sideName)
else:
print(sideName + " centroid x:" + str(centroidx))
print(sideName + " centroid y:" + str(centroidy))
print("")
if dispFlag:
small_thresh = cv.CreateImage(
(int(0.25 * cv.GetSize(imgbluethresh)[0]),
int(0.25 * cv.GetSize(imgbluethresh)[1])), 8, 1)
cv.Resize(imgbluethresh, small_thresh)
cv.ShowImage(sideName + "_threshold", small_thresh)
cv.WaitKey(100)
small_hsv = cv.CreateImage((int(
0.25 * cv.GetSize(imghsv)[0]), int(0.25 * cv.GetSize(imghsv)[1])),
8, 3)
cv.Resize(imghsv, small_hsv)
cv.ShowImage(sideName + "_hsv", small_hsv)
cv.WaitKey(100)
return (centroidx, centroidy)
def run(self):
# Capture first frame to get size
frame = cv.QueryFrame(self.capture)
#nframes =+ 1
frame_size = cv.GetSize(frame)
color_image = cv.CreateImage(cv.GetSize(frame), 8, 3)
grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
moving_average = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_32F, 3)
def totuple(a):
try:
return tuple(totuple(i) for i in a)
except TypeError:
return a
first = True
while True:
closest_to_left = cv.GetSize(frame)[0]
closest_to_right = cv.GetSize(frame)[1]
color_image = cv.QueryFrame(self.capture)
# Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)
if first:
difference = cv.CloneImage(color_image)
temp = cv.CloneImage(color_image)
cv.ConvertScale(color_image, moving_average, 1.0, 0.0)
first = False
else:
cv.RunningAvg(color_image, moving_average, .1, None)
cv.ShowImage("BG", moving_average)
# Convert the scale of the moving average.
cv.ConvertScale(moving_average, temp, 1, 0.0)
# Minus the current frame from the moving average.
cv.AbsDiff(color_image, temp, difference)
#cv.ShowImage("BG",difference)
# Convert the image to grayscale.
cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)
cv.ShowImage("BG1", grey_image)
# Convert the image to black and white.
cv.Threshold(grey_image, grey_image, 40, 255, cv.CV_THRESH_BINARY)
#cv.ShowImage("BG2", grey_image)
# Dilate and erode to get people blobs
cv.Dilate(grey_image, grey_image, None, 8)
cv.Erode(grey_image, grey_image, None, 3)
cv.ShowImage("BG3", grey_image)
storage = cv.CreateMemStorage(0)
global contour
contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP,
cv.CV_CHAIN_APPROX_SIMPLE)
points = []
while contour:
global bound_rect
bound_rect = cv.BoundingRect(list(contour))
polygon_points = cv.ApproxPoly(list(contour), storage,
cv.CV_POLY_APPROX_DP)
contour = contour.h_next()
global pt1, pt2
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2],
bound_rect[1] + bound_rect[3])
#size control
if (bound_rect[0] - bound_rect[2] >
10) and (bound_rect[1] - bound_rect[3] > 10):
points.append(pt1)
points.append(pt2)
#points += list(polygon_points)
global box, box2, box3, box4, box5
box = cv.MinAreaRect2(polygon_points)
box2 = cv.BoxPoints(box)
box3 = np.int0(np.around(box2))
box4 = totuple(box3)
box5 = box4 + (box4[0], )
cv.FillPoly(grey_image, [
list(polygon_points),
], cv.CV_RGB(255, 255, 255), 0, 0)
cv.PolyLine(color_image, [
polygon_points,
], 0, cv.CV_RGB(255, 255, 255), 1, 0, 0)
cv.PolyLine(color_image, [list(box5)], 0, (0, 0, 255), 2)
#cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255,0,0), 1)
if len(points):
#center_point = reduce(lambda a, b: ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2), points)
center1 = (pt1[0] + pt2[0]) / 2
center2 = (pt1[1] + pt2[1]) / 2
#print center1, center2, center_point
#cv.Circle(color_image, center_point, 40, cv.CV_RGB(255, 255, 255), 1)
#cv.Circle(color_image, center_point, 30, cv.CV_RGB(255, 100, 0), 1)
#cv.Circle(color_image, center_point, 20, cv.CV_RGB(255, 255, 255), 1)
cv.Circle(color_image, (center1, center2), 5,
cv.CV_RGB(0, 0, 255), -1)
cv.ShowImage("Target", color_image)
# Listen for ESC key
c = cv.WaitKey(7) % 0x100
if c == 27:
#cv.DestroyAllWindows()
break
def find(self, img):
started = time.time()
gray = self.Cached('gray', img.height, img.width, cv.CV_8UC1)
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
sobel = self.Cached('sobel', img.height, img.width, cv.CV_16SC1)
sobely = self.Cached('sobely', img.height, img.width, cv.CV_16SC1)
cv.Sobel(gray, sobel, 1, 0)
cv.Sobel(gray, sobely, 0, 1)
cv.Add(sobel, sobely, sobel)
sobel8 = self.Cached('sobel8', sobel.height, sobel.width, cv.CV_8UC1)
absnorm8(sobel, sobel8)
cv.Threshold(sobel8, sobel8, 128.0, 255.0, cv.CV_THRESH_BINARY)
sobel_integral = self.Cached('sobel_integral', img.height + 1,
img.width + 1, cv.CV_32SC1)
cv.Integral(sobel8, sobel_integral)
d = 16
_x1y1 = cv.GetSubRect(
sobel_integral,
(0, 0, sobel_integral.cols - d, sobel_integral.rows - d))
_x1y2 = cv.GetSubRect(
sobel_integral,
(0, d, sobel_integral.cols - d, sobel_integral.rows - d))
_x2y1 = cv.GetSubRect(
sobel_integral,
(d, 0, sobel_integral.cols - d, sobel_integral.rows - d))
_x2y2 = cv.GetSubRect(
sobel_integral,
(d, d, sobel_integral.cols - d, sobel_integral.rows - d))
summation = cv.CloneMat(_x2y2)
cv.Sub(summation, _x1y2, summation)
cv.Sub(summation, _x2y1, summation)
cv.Add(summation, _x1y1, summation)
sum8 = self.Cached('sum8', summation.height, summation.width,
cv.CV_8UC1)
absnorm8(summation, sum8)
cv.Threshold(sum8, sum8, 32.0, 255.0, cv.CV_THRESH_BINARY)
cv.ShowImage("sum8", sum8)
seq = cv.FindContours(sum8, cv.CreateMemStorage(), cv.CV_RETR_EXTERNAL)
subimg = cv.GetSubRect(img, (d / 2, d / 2, sum8.cols, sum8.rows))
t_cull = time.time() - started
seqs = []
while seq:
seqs.append(seq)
seq = seq.h_next()
started = time.time()
found = {}
print 'seqs', len(seqs)
for seq in seqs:
area = cv.ContourArea(seq)
if area > 1000:
rect = cv.BoundingRect(seq)
edge = int((14 / 14.) * math.sqrt(area) / 2 + 0.5)
candidate = cv.GetSubRect(subimg, rect)
sym = self.dm.decode(
candidate.width,
candidate.height,
buffer(candidate.tostring()),
max_count=1,
#min_edge = 6,
#max_edge = int(edge) # Units of 2 pixels
)
if sym:
onscreen = [(d / 2 + rect[0] + x, d / 2 + rect[1] + y)
for (x, y) in self.dm.stats(1)[1]]
found[sym] = onscreen
else:
print "FAILED"
t_brute = time.time() - started
print "cull took", t_cull, "brute", t_brute
return found
def run(self):
# Initialize
# log_file_name = "tracker_output.log"
# log_file = file( log_file_name, 'a' )
print "hello"
frame = cv.QueryFrame(self.capture)
frame_size = cv.GetSize(frame)
# Capture the first frame from webcam for image properties
display_image = cv.QueryFrame(self.capture)
# Greyscale image, thresholded to create the motion mask:
grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
# The RunningAvg() function requires a 32-bit or 64-bit image...
running_average_image = cv.CreateImage(cv.GetSize(frame),
cv.IPL_DEPTH_32F, 3)
# ...but the AbsDiff() function requires matching image depths:
running_average_in_display_color_depth = cv.CloneImage(display_image)
# RAM used by FindContours():
mem_storage = cv.CreateMemStorage(0)
# The difference between the running average and the current frame:
difference = cv.CloneImage(display_image)
target_count = 1
last_target_count = 1
last_target_change_t = 0.0
k_or_guess = 1
codebook = []
frame_count = 0
last_frame_entity_list = []
t0 = time.time()
# For toggling display:
image_list = ["camera", "difference", "threshold", "display", "faces"]
image_index = 3 # Index into image_list
# Prep for text drawing:
text_font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX, .5, .5, 0.0, 1,
cv.CV_AA)
text_coord = (5, 15)
text_color = cv.CV_RGB(255, 255, 255)
# Set this to the max number of targets to look for (passed to k-means):
max_targets = 5
while True:
# Capture frame from webcam
camera_image = cv.QueryFrame(self.capture)
frame_count += 1
frame_t0 = time.time()
# Create an image with interactive feedback:
display_image = cv.CloneImage(camera_image)
# Create a working "color image" to modify / blur
color_image = cv.CloneImage(display_image)
# Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 19, 0)
# Use the Running Average as the static background
# a = 0.020 leaves artifacts lingering way too long.
# a = 0.320 works well at 320x240, 15fps. (1/a is roughly num frames.)
cv.RunningAvg(color_image, running_average_image, 0.320, None)
# cv.ShowImage("background ", running_average_image)
# Convert the scale of the moving average.
cv.ConvertScale(running_average_image,
running_average_in_display_color_depth, 1.0, 0.0)
# Subtract the current frame from the moving average.
cv.AbsDiff(color_image, running_average_in_display_color_depth,
difference)
cv.ShowImage("difference ", difference)
# Convert the image to greyscale.
cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)
# Threshold the image to a black and white motion mask:
cv.Threshold(grey_image, grey_image, 2, 255, cv.CV_THRESH_BINARY)
# Smooth and threshold again to eliminate "sparkles"
cv.Smooth(grey_image, grey_image, cv.CV_GAUSSIAN, 19, 0)
cv.Threshold(grey_image, grey_image, 240, 255, cv.CV_THRESH_BINARY)
grey_image_as_array = numpy.asarray(cv.GetMat(grey_image))
non_black_coords_array = numpy.where(grey_image_as_array > 3)
# Convert from numpy.where()'s two separate lists to one list of (x, y) tuples:
non_black_coords_array = zip(non_black_coords_array[1],
non_black_coords_array[0])
points = [
] # Was using this to hold either pixel coords or polygon coords.
bounding_box_list = []
# Now calculate movements using the white pixels as "motion" data
contour = cv.FindContours(grey_image, mem_storage,
cv.CV_RETR_CCOMP,
cv.CV_CHAIN_APPROX_SIMPLE)
levels = 10
while contour:
bounding_rect = cv.BoundingRect(list(contour))
point1 = (bounding_rect[0], bounding_rect[1])
point2 = (bounding_rect[0] + bounding_rect[2],
bounding_rect[1] + bounding_rect[3])
bounding_box_list.append((point1, point2))
polygon_points = cv.ApproxPoly(list(contour), mem_storage,
cv.CV_POLY_APPROX_DP)
# To track polygon points only (instead of every pixel):
# points += list(polygon_points)
# Draw the contours:
cv.DrawContours(color_image, contour, cv.CV_RGB(255, 0, 0),
cv.CV_RGB(0, 255, 0), levels, 3, 0, (0, 0))
cv.FillPoly(grey_image, [
list(polygon_points),
], cv.CV_RGB(255, 255, 255), 0, 0)
cv.PolyLine(display_image, [
polygon_points,
], 0, cv.CV_RGB(255, 255, 255), 1, 0, 0)
# cv.Rectangle( display_image, point1, point2, cv.CV_RGB(120,120,120), 1)
contour = contour.h_next()
# Find the average size of the bbox (targets), then
# remove any tiny bboxes (which are prolly just noise).
# "Tiny" is defined as any box with 1/10th the area of the average box.
# This reduces false positives on tiny "sparkles" noise.
box_areas = []
for box in bounding_box_list:
box_width = box[right][0] - box[left][0]
box_height = box[bottom][0] - box[top][0]
box_areas.append(box_width * box_height)
# cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(255,0,0), 1)
average_box_area = 0.0
if len(box_areas):
average_box_area = float(sum(box_areas)) / len(box_areas)
trimmed_box_list = []
for box in bounding_box_list:
box_width = box[right][0] - box[left][0]
box_height = box[bottom][0] - box[top][0]
# Only keep the box if it's not a tiny noise box:
if (box_width * box_height) > average_box_area * 0.1:
trimmed_box_list.append(box)
# Draw the trimmed box list:
# for box in trimmed_box_list:
# cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(0,255,0), 2 )
bounding_box_list = merge_collided_bboxes(trimmed_box_list)
# Draw the merged box list:
for box in bounding_box_list:
cv.Rectangle(display_image, box[0], box[1],
cv.CV_RGB(0, 255, 0), 1)
# Here are our estimate points to track, based on merged & trimmed boxes:
estimated_target_count = len(bounding_box_list)
# Don't allow target "jumps" from few to many or many to few.
# Only change the number of targets up to one target per n seconds.
# This fixes the "exploding number of targets" when something stops moving
# and the motion erodes to disparate little puddles all over the place.
if frame_t0 - last_target_change_t < .350: # 1 change per 0.35 secs
estimated_target_count = last_target_count
else:
if last_target_count - estimated_target_count > 1:
estimated_target_count = last_target_count - 1
if estimated_target_count - last_target_count > 1:
estimated_target_count = last_target_count + 1
last_target_change_t = frame_t0
# Clip to the user-supplied maximum:
estimated_target_count = min(estimated_target_count, max_targets)
# The estimated_target_count at this point is the maximum number of targets
# we want to look for. If kmeans decides that one of our candidate
# bboxes is not actually a target, we remove it from the target list below.
# Using the numpy values directly (treating all pixels as points):
points = non_black_coords_array
center_points = []
if len(points):
# If we have all the "target_count" targets from last frame,
# use the previously known targets (for greater accuracy).
k_or_guess = max(estimated_target_count,
1) # Need at least one target to look for.
if len(codebook) == estimated_target_count:
k_or_guess = codebook
# points = vq.whiten(array( points )) # Don't do this! Ruins everything.
codebook, distortion = vq.kmeans(array(points), k_or_guess)
# Convert to tuples (and draw it to screen)
for center_point in codebook:
center_point = (int(center_point[0]), int(center_point[1]))
center_points.append(center_point)
# cv.Circle(display_image, center_point, 10, cv.CV_RGB(255, 0, 0), 2)
# cv.Circle(display_image, center_point, 5, cv.CV_RGB(255, 0, 0), 3)
# Now we have targets that are NOT computed from bboxes -- just
# movement weights (according to kmeans). If any two targets are
# within the same "bbox count", average them into a single target.
#
# (Any kmeans targets not within a bbox are also kept.)
trimmed_center_points = []
removed_center_points = []
for box in bounding_box_list:
# Find the centers within this box:
center_points_in_box = []
for center_point in center_points:
if center_point[0] < box[right][0] and center_point[0] > box[left][0] and \
center_point[1] < box[bottom][1] and center_point[1] > box[top][1] :
# This point is within the box.
center_points_in_box.append(center_point)
# Now see if there are more than one. If so, merge them.
if len(center_points_in_box) > 1:
# Merge them:
x_list = y_list = []
for point in center_points_in_box:
x_list.append(point[0])
y_list.append(point[1])
average_x = int(float(sum(x_list)) / len(x_list))
average_y = int(float(sum(y_list)) / len(y_list))
trimmed_center_points.append((average_x, average_y))
# Record that they were removed:
removed_center_points += center_points_in_box
if len(center_points_in_box) == 1:
trimmed_center_points.append(
center_points_in_box[0]) # Just use it.
# If there are any center_points not within a bbox, just use them.
# (It's probably a cluster comprised of a bunch of small bboxes.)
for center_point in center_points:
if (not center_point in trimmed_center_points) and (
not center_point in removed_center_points):
trimmed_center_points.append(center_point)
# Draw what we found:
# for center_point in trimmed_center_points:
# center_point = ( int(center_point[0]), int(center_point[1]) )
# cv.Circle(display_image, center_point, 20, cv.CV_RGB(255, 255,255), 1)
# cv.Circle(display_image, center_point, 15, cv.CV_RGB(100, 255, 255), 1)
# cv.Circle(display_image, center_point, 10, cv.CV_RGB(255, 255, 255), 2)
# cv.Circle(display_image, center_point, 5, cv.CV_RGB(100, 255, 255), 3)
# Determine if there are any new (or lost) targets:
actual_target_count = len(trimmed_center_points)
last_target_count = actual_target_count
# Now build the list of physical entities (objects)
this_frame_entity_list = []
# An entity is list: [ name, color, last_time_seen, last_known_coords ]
for target in trimmed_center_points:
# Is this a target near a prior entity (same physical entity)?
entity_found = False
entity_distance_dict = {}
for entity in last_frame_entity_list:
entity_coords = entity[3]
delta_x = entity_coords[0] - target[0]
delta_y = entity_coords[1] - target[1]
distance = sqrt(pow(delta_x, 2) + pow(delta_y, 2))
entity_distance_dict[distance] = entity
# Did we find any non-claimed entities (nearest to furthest):
distance_list = entity_distance_dict.keys()
distance_list.sort()
for distance in distance_list:
# Yes; see if we can claim the nearest one:
nearest_possible_entity = entity_distance_dict[distance]
# Don't consider entities that are already claimed:
if nearest_possible_entity in this_frame_entity_list:
# print "Target %s: Skipping the one iwth distance: %d at %s, C:%s" % (target, distance, nearest_possible_entity[3], nearest_possible_entity[1] )
continue
# print "Target %s: USING the one iwth distance: %d at %s, C:%s" % (target, distance, nearest_possible_entity[3] , nearest_possible_entity[1])
# Found the nearest entity to claim:
entity_found = True
nearest_possible_entity[
2] = frame_t0 # Update last_time_seen
nearest_possible_entity[
3] = target # Update the new location
this_frame_entity_list.append(nearest_possible_entity)
# log_file.write( "%.3f MOVED %s %d %d\n" % ( frame_t0, nearest_possible_entity[0], nearest_possible_entity[3][0], nearest_possible_entity[3][1] ) )
break
if entity_found == False:
# It's a new entity.
color = (random.randint(0, 255), random.randint(0, 255),
random.randint(0, 255))
name = hashlib.md5(str(frame_t0) +
str(color)).hexdigest()[:6]
last_time_seen = frame_t0
new_entity = [name, color, last_time_seen, target]
this_frame_entity_list.append(new_entity)
# log_file.write( "%.3f FOUND %s %d %d\n" % ( frame_t0, new_entity[0], new_entity[3][0], new_entity[3][1] ) )
# Now "delete" any not-found entities which have expired:
entity_ttl = 1.0 # 1 sec.
for entity in last_frame_entity_list:
last_time_seen = entity[2]
if frame_t0 - last_time_seen > entity_ttl:
# It's gone.
# log_file.write( "%.3f STOPD %s %d %d\n" % ( frame_t0, entity[0], entity[3][0], entity[3][1] ) )
pass
else:
# Save it for next time... not expired yet:
this_frame_entity_list.append(entity)
# For next frame:
last_frame_entity_list = this_frame_entity_list
# Draw the found entities to screen:
for entity in this_frame_entity_list:
center_point = entity[3]
c = entity[1] # RGB color tuple
cv.Circle(display_image, center_point, 20,
cv.CV_RGB(c[0], c[1], c[2]), 1)
cv.Circle(display_image, center_point, 15,
cv.CV_RGB(c[0], c[1], c[2]), 1)
cv.Circle(display_image, center_point, 10,
cv.CV_RGB(c[0], c[1], c[2]), 2)
cv.Circle(display_image, center_point, 5,
cv.CV_RGB(c[0], c[1], c[2]), 3)
# print "min_size is: " + str(min_size)
# Listen for ESC or ENTER key
c = cv.WaitKey(7) % 0x100
if c == 27 or c == 10:
break
# Toggle which image to show
# if chr(c) == 'd':
# image_index = ( image_index + 1 ) % len( image_list )
#
# image_name = image_list[ image_index ]
#
# # Display frame to user
# if image_name == "camera":
# image = camera_image
# cv.PutText( image, "Camera (Normal)", text_coord, text_font, text_color )
# elif image_name == "difference":
# image = difference
# cv.PutText( image, "Difference Image", text_coord, text_font, text_color )
# elif image_name == "display":
# image = display_image
# cv.PutText( image, "Targets (w/AABBs and contours)", text_coord, text_font, text_color )
# elif image_name == "threshold":
# # Convert the image to color.
# cv.CvtColor( grey_image, display_image, cv.CV_GRAY2RGB )
# image = display_image # Re-use display image here
# cv.PutText( image, "Motion Mask", text_coord, text_font, text_color )
# elif image_name == "faces":
# # Do face detection
# detect_faces( camera_image, haar_cascade, mem_storage )
# image = camera_image # Re-use camera image here
# cv.PutText( image, "Face Detection", text_coord, text_font, text_color )
# cv.ShowImage( "Target", image )
image1 = display_image
cv.ShowImage("Target 1", image1)
# if self.writer:
# cv.WriteFrame( self.writer, image );
# log_file.flush()
# If only using a camera, then there is no time.sleep() needed,
# because the camera clips us to 15 fps. But if reading from a file,
# we need this to keep the time-based target clipping correct:
frame_t1 = time.time()
# If reading from a file, put in a forced delay:
if not self.writer:
delta_t = frame_t1 - frame_t0
if delta_t < (1.0 / 15.0): time.sleep((1.0 / 15.0) - delta_t)
t1 = time.time()
time_delta = t1 - t0
processed_fps = float(frame_count) / time_delta
print "Got %d frames. %.1f s. %f fps." % (frame_count, time_delta,
processed_fps)
def run(self):
logging.debug(' starting run ')
global samecolorclient
global capture
global centroidList #abh
global lock #abh
global lock2 #abh
global lock3 #abh
global lock4 #abh
mydata = threading.local()
#window1=" Color Detection"
mydata.window2 = str(self.name) + " Threshold"
#cv.NamedWindow(window1,0)
lock4.acquire() #abh
cv.NamedWindow(mydata.window2, 0)
lock4.release() #abh
mydata.centroidold = [0, 0]
mydata.flag = 0
mydata.roi = [100, 22, 390, 390]
#mydata.roi=[95,40,380,350]
while True:
lock2.acquire() #abh
lock4.acquire() #abh
mydata.color_image = cv.QueryFrame(capture)
lock4.release() #abh
lock2.release() #abh
if (mydata.flag == 0):
lock4.acquire #abh lock4.release #abh
mydata.color_image = cv.GetSubRect(mydata.color_image,
(100, 22, 390, 390))
lock4.release #abh
else:
lock4.acquire #abh lock4.release #abh
mydata.color_image = cv.GetSubRect(
mydata.color_image,
(int(mydata.roi[0]), int(mydata.roi[1]), int(
mydata.roi[2]), int(mydata.roi[3])))
lock4.release #abh
lock4.acquire #abh lock4.release #abh
cv.Flip(mydata.color_image, mydata.color_image, 1)
cv.Smooth(mydata.color_image, mydata.color_image, cv.CV_MEDIAN, 3,
0)
#logging.debug(' Starting getthresholdedimg ')
mydata.imghsv = cv.CreateImage(cv.GetSize(mydata.color_image), 8,
3)
cv.CvtColor(mydata.color_image, mydata.imghsv,
cv.CV_BGR2YCrCb) # Convert image from RGB to HSV
mydata.imgnew = cv.CreateImage(cv.GetSize(mydata.color_image),
cv.IPL_DEPTH_8U, 1)
mydata.imgthreshold = cv.CreateImage(
cv.GetSize(mydata.color_image), 8, 1)
lock4.release #abh
mydata.c = self.color[0]
mydata.minc = (float(mydata.c[0]), float(mydata.c[1]),
float(mydata.c[2]))
mydata.c = self.color[1]
mydata.maxc = (float(mydata.c[0]), float(mydata.c[1]),
float(mydata.c[2]))
lock4.acquire #abh lock4.release #abh
cv.InRangeS(mydata.imghsv, cv.Scalar(*(mydata.minc)),
cv.Scalar(*(mydata.maxc)), mydata.imgnew)
cv.Add(mydata.imgnew, mydata.imgthreshold, mydata.imgthreshold)
#logging.debug(' Exiting getthreasholdedimg')
#logging.debug('function returned from thresholdedimg')
cv.Erode(mydata.imgthreshold, mydata.imgthreshold, None, 1)
cv.Dilate(mydata.imgthreshold, mydata.imgthreshold, None, 4)
mydata.img2 = cv.CloneImage(mydata.imgthreshold)
mydata.storage = cv.CreateMemStorage(0)
mydata.contour = cv.FindContours(mydata.imgthreshold,
mydata.storage,
cv.CV_RETR_EXTERNAL,
cv.CV_CHAIN_APPROX_SIMPLE)
lock4.release #abh
mydata.points = []
#logging.debug('Starting while contour')
while mydata.contour:
# Draw bounding rectangles
lock4.acquire #abh lock4.release #abh
mydata.bound_rect = cv.BoundingRect(list(mydata.contour))
lock4.release #abh
mydata.contour = mydata.contour.h_next()
mydata.pt1 = (mydata.bound_rect[0], mydata.bound_rect[1])
mydata.pt2 = (mydata.bound_rect[0] + mydata.bound_rect[2],
mydata.bound_rect[1] + mydata.bound_rect[3])
mydata.points.append(mydata.pt1)
mydata.points.append(mydata.pt2)
lock4.acquire #abh lock4.release #abh
cv.Rectangle(
mydata.color_image, mydata.pt1, mydata.pt2,
cv.CV_RGB(mydata.maxc[0], mydata.maxc[1], mydata.maxc[2]),
1)
lock4.release #abh
# Calculating centroids
if (((mydata.bound_rect[2]) * (mydata.bound_rect[3])) < 3500):
#logging.debug('Inside iffffffffffffffffffffffff')
lock4.acquire #abh lock4.release #abh
mydata.centroidx = cv.Round(
(mydata.pt1[0] + mydata.pt2[0]) / 2)
mydata.centroidy = cv.Round(
(mydata.pt1[1] + mydata.pt2[1]) / 2)
lock4.release #abh
if (mydata.flag == 1):
#logging.debug("inside flag1")
mydata.centroidx = mydata.roi[0] + mydata.centroidx
mydata.centroidy = mydata.roi[1] + mydata.centroidy
mydata.centroidnew = [mydata.centroidx, mydata.centroidy]
#logging.debug('mydataroi[0] '+str(mydata.roi[0]) + ';centroidx ' + str(mydata.centroidx))
#logging.debug('mydataroi[1] '+str(mydata.roi[1]) + ';centroidy ' + str(mydata.centroidy))
#print mydata.centroidx #abh
#print mydata.centroidy #abh
mydata.tmpclient = []
lock3.acquire() #abh
mydata.tmpclient = samecolorclient[self.i]
lock3.release() #abh
mydata.distance = math.sqrt(
math.pow((mydata.centroidnew[0] -
mydata.centroidold[0]), 2) +
math.pow((mydata.centroidnew[1] -
mydata.centroidold[1]), 2))
#lock.acquire() #abh #abh commented
for mydata.j in range(len(mydata.tmpclient)):
mydata.client_socket = mydata.tmpclient[mydata.j]
#logging.debug('before centroid send...')
if (mydata.distance >= 1.50):
print 'inside 1.50 '
#self.server_socket.sendto(str(mydata.centroidnew),mydata.client_socket) #abh
lock.acquire() #abh
centroidList[colorlist.index(
self.color)] = mydata.centroidnew #abh
del mydata.centroidold[:]
#logging.debug(str(centroidList))
self.server_socket.sendto(
str(centroidList), mydata.client_socket) #abh
lock.release() #abh
#logging.debug ('updating done.') #abh
#print centroidList #abh
mydata.centroidold = mydata.centroidnew[:]
else:
#self.server_socket.sendto(str(mydata.centroidold),mydata.client_socket) #abh
lock.acquire() #abh
centroidList[colorlist.index(
self.color)] = mydata.centroidold #abh
#logging.debug(str(centroidList))
self.server_socket.sendto(
str(centroidList), mydata.client_socket) #abh
lock.release() #abh
#logging.debug ('updating done2.') #abh
#print centroidList #abh
# logging.debug('byte sent to client')
#lock.release() #abh
mydata.roi[0] = mydata.centroidx - 50
mydata.roi[1] = mydata.centroidy - 50
if (mydata.roi[0] < 95):
mydata.roi[0] = 95
if (mydata.roi[1] < 40):
mydata.roi[1] = 40
mydata.roi[2] = 100
mydata.roi[3] = 100
if ((mydata.roi[0] + mydata.roi[2]) > 475):
mydata.roi[0] = mydata.roi[0] - (
(mydata.roi[0] + mydata.roi[2]) - 475)
if ((mydata.roi[1] + mydata.roi[3]) > 390):
mydata.roi[1] = mydata.roi[1] - (
(mydata.roi[1] + mydata.roi[3]) - 390)
#del mydata.centroidnew[:]
mydata.flag = 1
if mydata.contour is None:
mydata.flag = 0
#cv.ShowImage(window1,mydata.color_image)
lock4.acquire #abh lock4.release #abh
cv.ShowImage(mydata.window2, mydata.img2)
lock4.release #abh
if cv.WaitKey(33) == 27: #here it was 33 instead of 10
#cv.DestroyWindow(mydata.window1)
#cv.DestroyWindow(mydata.window2)
break
def findBlob(rgbimage, hsvimage, maskimage, blobimage, hsvcolorrange, hsvmin,
hsvmax):
cv.CvtColor(rgbimage, hsvimage, cv.CV_BGR2HSV)
hsvmin = [
hsvmin[0] - hsvcolorrange[0], hsvmin[1] - hsvcolorrange[1],
hsvmin[2] - hsvcolorrange[2]
]
hsvmax = [
hsvmax[0] + hsvcolorrange[0], hsvmax[1] + hsvcolorrange[1],
hsvmax[2] + hsvcolorrange[2]
]
if hsvmin[0] < 0:
hsvmin[0] = 0
if hsvmin[1] < 0:
hsvmin[1] = 0
if hsvmin[2] < 0:
hsvmin[2] = 0
if hsvmax[0] > 255:
hsvmax[0] = 255
if hsvmax[1] > 255:
hsvmax[1] = 255
if hsvmax[2] > 255:
hsvmax[2] = 255
cv.InRangeS(hsvimage, cv.Scalar(hsvmin[0], hsvmin[1], hsvmin[2]),
cv.Scalar(hsvmax[0], hsvmax[1], hsvmax[2]), maskimage)
element = cv.CreateStructuringElementEx(5, 5, 2, 2, cv.CV_SHAPE_RECT)
cv.Erode(maskimage, maskimage, element, 1)
cv.Dilate(maskimage, maskimage, element, 1)
storage = cv.CreateMemStorage(0)
cv.Copy(maskimage, blobimage)
contour = cv.FindContours(maskimage, storage, cv.CV_RETR_CCOMP,
cv.CV_CHAIN_APPROX_SIMPLE)
trackedpoint = None
maxtrackedpoint = None
maxareasize = 0
#You can tune these value to improve tracking
maxarea = 0
minarea = 1
areasize = 0
while contour:
bound_rect = cv.BoundingRect(list(contour))
contour = contour.h_next()
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3])
areasize = fabs(bound_rect[2] * bound_rect[3])
if (areasize > maxareasize):
maxareasize = areasize
maxtrackedpoint = (int(
(pt1[0] + pt2[0]) / 2), int((pt1[1] + pt2[1]) / 2), 1.0)
cv.Rectangle(rgb_image, pt1, pt2, cv.CV_RGB(255, 0, 0), 1)
trackedpoint = maxtrackedpoint
if (trackedpoint != None):
cv.Circle(rgb_image, (trackedpoint[0], trackedpoint[1]), 5,
cv.CV_RGB(255, 0, 0), 1)
return trackedpoint
def run(self):
# Capture first frame to get size
frame = self.get_image2()
frame_size = cv.GetSize(frame)
color_image = cv.CreateImage(frame_size, 8, 3)
grey_image = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 1)
moving_average = cv.CreateImage(frame_size, cv.IPL_DEPTH_32F, 3)
first = True
while True:
closest_to_left = cv.GetSize(frame)[0]
closest_to_right = cv.GetSize(frame)[1]
print "getting Image"
color_image = self.get_image2()
print "got image"
# Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)
if first:
difference = cv.CloneImage(color_image)
temp = cv.CloneImage(color_image)
cv.ConvertScale(color_image, moving_average, 1.0, 0.0)
first = False
else:
cv.RunningAvg(color_image, moving_average, 0.30, None)
# Convert the scale of the moving average.
cv.ConvertScale(moving_average, temp, 1.0, 0.0)
# Minus the current frame from the moving average.
cv.AbsDiff(color_image, temp, difference)
# Convert the image to grayscale.
cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)
# Convert the image to black and white.
cv.Threshold(grey_image, grey_image, 70, 255, cv.CV_THRESH_BINARY)
# Dilate and erode to get people blobs
cv.Dilate(grey_image, grey_image, None, 18)
cv.Erode(grey_image, grey_image, None, 10)
storage = cv.CreateMemStorage(0)
contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE)
points = []
while contour:
bound_rect = cv.BoundingRect(list(contour))
contour = contour.h_next()
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3])
points.append(pt1)
points.append(pt2)
cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255,0,0), 1)
if len(points):
center_point = reduce(lambda a, b: ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2), points)
cv.Circle(color_image, center_point, 40, cv.CV_RGB(255, 255, 255), 1)
cv.Circle(color_image, center_point, 30, cv.CV_RGB(255, 100, 0), 1)
cv.Circle(color_image, center_point, 20, cv.CV_RGB(255, 255, 255), 1)
cv.Circle(color_image, center_point, 10, cv.CV_RGB(255, 100, 0), 1)
cv.ShowImage("Target", color_image)
# Listen for ESC key
c = cv.WaitKey(7) % 0x100
if c == 27:
break
def detect(self):
self.log("Start detection thread")
### open cam ###
cap = vc.VideoCapture(self._videoInput, self).capture
if cap == None:
self.log("Can't open camera!")
self.active = False
return
cap.setFPS(self._fps)
cap.setVideoSize(self._videoSize)
cap.setBin(self._bin)
cap.setGain(self._gain)
### init ###
frame, ts = cap.getFrame()
if not frame:
self.log("Error reading first frame")
self.active = False
return
frameSize = cv.GetSize(frame)
darkframe = None
if self._darkframe:
try:
darkframe = cv.LoadImage(self._darkframe)
if frameSize != cv.GetSize(darkframe):
darkframe = None
self.log("Darkframe has wrong size")
except:
self.log("Darkframe not found")
mask = None
'''
if self._mask:
try:
tmp = cv.LoadImage(self._mask)
mask = cv.CreateImage( frameSize, cv.IPL_DEPTH_8U, 1)
cv.CvtColor( tmp, mask, cv.CV_RGB2GRAY )
if frameSize != cv.GetSize(mask):
raise Exception();
except:
self.log("Mask not found or wrong size")
'''
small, smallSize = self.workingThumb(frame, frameSize)
runAvg = cv.CreateImage( smallSize, cv.IPL_DEPTH_32F, small.channels)
runAvgDisplay = cv.CreateImage(smallSize, small.depth, small.channels)
differenceImg = cv.CreateImage(smallSize, small.depth, small.channels)
grayImg = cv.CreateImage(smallSize, cv.IPL_DEPTH_8U, 1)
historyBuffer = imagestack.Imagestack(self._prevFrames)
capbuf = None
videoGap = self._maxVideoGap
postFrames = 0
frameCount = 1
detect = False
newVideo = True
### testwindow
if self._showWindow:
self.log("Show window")
cv.NamedWindow("Thread " + str(self._thread), 1)
### server
if self._runServer:
self.log("Start Server on port %d" % self._serverPort)
self._server = httpserver.httpserver(self._serverPort)
### capture loop ###
while self._run:
frame, ts = cap.getFrame()
if ts == None:
ts = time.time()
### create small image for detection
small, smallSize = self.workingThumb(frame, frameSize)
videoGap += 1
if small:
frameCount += 1
if 1/float(frameCount) < self._avgLevel and not detect:
self.log("start detection")
detect = True
### substract darkframe
if darkframe:
cv.Sub( frame, darkframe, frame )
if self._deNoiseLevel > 0:
cv.Smooth( small, small, cv.CV_MEDIAN, self._deNoiseLevel)
cv.RunningAvg( small, runAvg, self._avgLevel, mask )
cv.ConvertScale( runAvg, runAvgDisplay, 1.0, 0.0 )
cv.AbsDiff( small, runAvgDisplay, differenceImg )
if differenceImg.depth == grayImg.depth:
grayImg = differenceImg
else:
cv.CvtColor( differenceImg, grayImg, cv.CV_RGB2GRAY )
cv.Threshold( grayImg, grayImg, self._detectThresh, 255, cv.CV_THRESH_BINARY )
contour = cv.FindContours( grayImg, cv.CreateMemStorage(0), cv.CV_RETR_EXTERNAL, cv.CV_CHAIN_APPROX_SIMPLE)
## draw bounding rect
while contour:
bounding_rect = cv.BoundingRect( list(contour) )
area = bounding_rect[2]*bounding_rect[3]
if area > self._minRectArea and area < self._maxRectArea and detect:
videoGap = 0
#print(str(area))
self.log("motion detected...")
if self._drawRect:
self.drawBoundingRect(frame, bounding_rect, smallSize = smallSize)
contour = contour.h_next()
## add text notations
ms = "%04d" % int( (ts-int(ts)) * 10000 )
t = time.strftime("%Y-%m-%d %H:%M:%S." + ms + " UTC", time.gmtime(ts))
frame = self.addText(frame, self._texttl, t)
## save / show frame
if videoGap < self._maxVideoGap:
if newVideo:
self.log("Found motion, start capturing")
capbuf = []
newVideo = False
directory = os.path.join(self._videoDir,
"%d/%02d/%s" % (time.gmtime(ts).tm_year, time.gmtime(ts).tm_mon, t))
if not self.isWriteable(directory):
self._log(directory + "is not writeable!")
self._run = False
continue
capbuf.extend(historyBuffer.getImages())
capbuf.append({'img' : frame, 'time' : t})
else:
if postFrames < self._postFrames and not newVideo:
capbuf.append({'img' : frame, 'time' : t})
postFrames += 1
elif not newVideo:
self.log("Stop capturing")
### write images to hdd in new thread ###
thread.start_new(self.saveVideo, (directory, capbuf))
capbuf = None
postFrames = 0
newVideo = True
######## Add Frame to history buffer ########
historyBuffer.add(cv.CloneImage( frame ), t)
######## Window ########
if self._showWindow:
cv.ShowImage("Thread " + str(self._thread), frame)
cv.ShowImage("Thread %d avg" % self._thread, runAvgDisplay)
cv.ShowImage("Thread %d diff" % self._thread, differenceImg)
cv.WaitKey(1)
######## Update Server ########
if self._server:
self._server.updateImage(cv.CloneImage( frame ))
self.log("Proc: " + str(time.time() - ts))
else:
self.log("no more frames (" + str(frameCount) +" frames)")
break
self.log("Close camera")
cap.close()
if self._server:
self.log("Close server")
self._server.shutdown()
self.log("end detection thread " + str(self._thread))
self.active = False
def run(self):
# Initialize
log_file_name = "tracker_output.log"
log_file = open( log_file_name, 'a' )
#fps = 25
#cap = cv2.VideoCapture( '../000104-.avi'
frame = cv.QueryFrame( self.capture )
frame_size = cv.GetSize( frame )
foreground = cv.CreateImage(cv.GetSize(frame),8,1)
foremat = cv.GetMat(foreground)
Nforemat = numpy.array(foremat, dtype=numpy.float32)
gfilter=sys.argv[2]
gfilter_string=gfilter
gfilter=float(gfilter)
print "Processing Tracker with filter: " + str(gfilter)
# Capture the first frame from webcam for image properties
display_image = cv.QueryFrame( self.capture )
# Create Background Subtractor
fgbg = cv2.BackgroundSubtractorMOG()
# Greyscale image, thresholded to create the motion mask:
grey_image = cv.CreateImage( cv.GetSize(frame), cv.IPL_DEPTH_8U, 1 )
# The RunningAvg() function requires a 32-bit or 64-bit image...
running_average_image = cv.CreateImage( cv.GetSize(frame), cv.IPL_DEPTH_32F, 3 )
# ...but the AbsDiff() function requires matching image depths:
running_average_in_display_color_depth = cv.CloneImage( display_image )
# RAM used by FindContours():
mem_storage = cv.CreateMemStorage(0)
# The difference between the running average and the current frame:
difference = cv.CloneImage( display_image )
target_count = 1
last_target_count = 1
last_target_change_t = 0.0
k_or_guess = 1
codebook=[]
frame_count=0
last_frame_entity_list = []
fps = 25
t0 = 165947
# For toggling display:
image_list = [ "camera", "shadow", "white", "threshold", "display", "yellow" ]
image_index = 0 # Index into image_list
# Prep for text drawing:
text_font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX, .5, .5, 0.0, 1, cv.CV_AA )
text_coord = ( 5, 15 )
text_color = cv.CV_RGB(255,255,255)
text_coord2 = ( 5, 30 )
text_coord3 = ( 5, 45 )
###############################
### Face detection stuff
#haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_default.xml' )
#haar_cascade = cv.Load( 'C:/OpenCV2.2/data/haarcascades/haarcascade_frontalface_alt.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_alt2.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_mcs_mouth.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_eye.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_alt_tree.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_upperbody.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_profileface.xml' )
# Set this to the max number of targets to look for (passed to k-means):
max_targets = 20
while True:
# Capture frame from webcam
camera_image = cv.QueryFrame( self.capture )
#ret, frame = cap.read()
frame_count += 1
frame_t0 = time.time()
mat = cv.GetMat(camera_image)
Nmat = numpy.array(mat, dtype=numpy.uint8)
# Create an image with interactive feedback:
display_image = cv.CloneImage( camera_image )
# NEW INSERT - FGMASK
fgmask = fgbg.apply(Nmat,Nforemat,-1)
fgmask = cv.fromarray(fgmask)
# Create a working "color image" to modify / blur
color_image = cv.CloneImage( display_image )
# Smooth to get rid of false positives
cv.Smooth( color_image, color_image, cv.CV_GAUSSIAN, 19, 0 ) #Changed from 19 AND MADE MEDIAN FILTER
# Smooth to get rid of false positives
# color_image = numpy.asarray( cv.GetMat( color_image ) )
# (mu, sigma) = cv2.meanStdDev(color_image)
# edges = cv2.Canny(color_image, mu - sigma, mu + sigma)
# lines = cv2.HoughLines(edges, 1, pi / 180, 70)
# Use the Running Average as the static background
# a = 0.020 leaves artifacts lingering way too long.
# a = 0.320 works well at 320x240, 15fps. (1/a is roughly num frames.)
cv.RunningAvg( color_image, running_average_image, gfilter, None )
# Convert the scale of the moving average.
cv.ConvertScale( running_average_image, running_average_in_display_color_depth, 1.0, 0.0 )
# Subtract the current frame from the moving average.
cv.AbsDiff( color_image, running_average_in_display_color_depth, difference )
# Convert the image to greyscale.
cv.CvtColor( difference, grey_image, cv.CV_RGB2GRAY )
# Smooth Before thresholding
cv.Smooth( grey_image, grey_image, cv.CV_GAUSSIAN, 19, 19 )
# Threshold the image to a black and white motion mask:
cv.Threshold( grey_image, grey_image, 2, 255, cv.CV_THRESH_BINARY )
# Smooth and threshold again to eliminate "sparkles"
#cv.Smooth( grey_image, grey_image, cv.CV_GAUSSIAN, 19, 0 ) #changed from 19 - AND put smooth before threshold
cv.Threshold( grey_image, grey_image, 240, 255, cv.CV_THRESH_BINARY)
grey_image_as_array = numpy.asarray( cv.GetMat( grey_image ) )
non_black_coords_array = numpy.where( grey_image_as_array > 3 )
# Convert from numpy.where()'s two separate lists to one list of (x, y) tuples:
non_black_coords_array = zip( non_black_coords_array[1], non_black_coords_array[0] )
frame_hsv = cv.CreateImage(cv.GetSize(color_image),8,3)
cv.CvtColor(color_image,frame_hsv,cv.CV_BGR2HSV)
imgthreshold_yellow=cv.CreateImage(cv.GetSize(color_image),8,1)
imgthreshold_white=cv.CreateImage(cv.GetSize(color_image),8,1)
imgthreshold_white2=cv.CreateImage(cv.GetSize(color_image),8,1)
cv.InRangeS(frame_hsv,cv.Scalar(0,0,196),cv.Scalar(255,255,255),imgthreshold_white) # changed scalar from 255,15,255 to 255,255,255
cv.InRangeS(frame_hsv,cv.Scalar(41,43,224),cv.Scalar(255,255,255),imgthreshold_white2)
cv.InRangeS(frame_hsv,cv.Scalar(20,100,100),cv.Scalar(30,255,255),imgthreshold_yellow)
#cvCvtColor(color_image, yellowHSV, CV_BGR2HSV)
#lower_yellow = np.array([10, 100, 100], dtype=np.uint8)
#upper_yellow = np.array([30, 255, 255], dtype=np.uint8)
#mask_yellow = cv2.inRange(yellowHSV, lower_yellow, upper_yellow)
#res_yellow = cv2.bitwise_and(color_image, color_image, mask_yellow = mask_yellow)
points = [] # Was using this to hold either pixel coords or polygon coords.
bounding_box_list = []
# Now calculate movements using the white pixels as "motion" data
contour = cv.FindContours( grey_image, mem_storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE )
i=0
while contour:
# c = contour[i]
# m = cv2.moments(c)
# Area = m['m00']
# print( Area )
bounding_rect = cv.BoundingRect( list(contour) )
point1 = ( bounding_rect[0], bounding_rect[1] )
point2 = ( bounding_rect[0] + bounding_rect[2], bounding_rect[1] + bounding_rect[3] )
bounding_box_list.append( ( point1, point2 ) )
polygon_points = cv.ApproxPoly( list(contour), mem_storage, cv.CV_POLY_APPROX_DP )
# To track polygon points only (instead of every pixel):
#points += list(polygon_points)
# Draw the contours:
###cv.DrawContours(color_image, contour, cv.CV_RGB(255,0,0), cv.CV_RGB(0,255,0), levels, 3, 0, (0,0) )
cv.FillPoly( grey_image, [ list(polygon_points), ], cv.CV_RGB(255,255,255), 0, 0 )
cv.PolyLine( display_image, [ polygon_points, ], 0, cv.CV_RGB(255,255,255), 1, 0, 0 )
#cv.Rectangle( display_image, point1, point2, cv.CV_RGB(120,120,120), 1)
# if Area > 3000:
# cv2.drawContours(imgrgb,[cnt],0,(255,255,255),2)
# print(Area)
i=i+1
contour = contour.h_next()
# Find the average size of the bbox (targets), then
# remove any tiny bboxes (which are prolly just noise).
# "Tiny" is defined as any box with 1/10th the area of the average box.
# This reduces false positives on tiny "sparkles" noise.
box_areas = []
for box in bounding_box_list:
box_width = box[right][0] - box[left][0]
box_height = box[bottom][0] - box[top][0]
box_areas.append( box_width * box_height )
#cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(255,0,0), 1)
average_box_area = 0.0
if len(box_areas): average_box_area = float( sum(box_areas) ) / len(box_areas)
trimmed_box_list = []
for box in bounding_box_list:
box_width = box[right][0] - box[left][0]
box_height = box[bottom][0] - box[top][0]
# Only keep the box if it's not a tiny noise box:
if (box_width * box_height) > average_box_area*0.1: trimmed_box_list.append( box )
# Draw the trimmed box list:
#for box in trimmed_box_list:
# cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(0,255,0), 2 )
bounding_box_list = merge_collided_bboxes( trimmed_box_list )
# Draw the merged box list:
for box in bounding_box_list:
cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(0,255,0), 1 )
# Here are our estimate points to track, based on merged & trimmed boxes:
estimated_target_count = len( bounding_box_list )
# Don't allow target "jumps" from few to many or many to few.
# Only change the number of targets up to one target per n seconds.
# This fixes the "exploding number of targets" when something stops moving
# and the motion erodes to disparate little puddles all over the place.
if frame_t0 - last_target_change_t < .35: # 1 change per 0.35 secs
estimated_target_count = last_target_count
else:
if last_target_count - estimated_target_count > 1: estimated_target_count = last_target_count - 1
if estimated_target_count - last_target_count > 1: estimated_target_count = last_target_count + 1
last_target_change_t = frame_t0
# Clip to the user-supplied maximum:
estimated_target_count = min( estimated_target_count, max_targets )
# The estimated_target_count at this point is the maximum number of targets
# we want to look for. If kmeans decides that one of our candidate
# bboxes is not actually a target, we remove it from the target list below.
# Using the numpy values directly (treating all pixels as points):
points = non_black_coords_array
center_points = []
if len(points):
# If we have all the "target_count" targets from last frame,
# use the previously known targets (for greater accuracy).
k_or_guess = max( estimated_target_count, 1 ) # Need at least one target to look for.
if len(codebook) == estimated_target_count:
k_or_guess = codebook
#points = vq.whiten(array( points )) # Don't do this! Ruins everything.
codebook, distortion = vq.kmeans( array( points ), k_or_guess )
# Convert to tuples (and draw it to screen)
for center_point in codebook:
center_point = ( int(center_point[0]), int(center_point[1]) )
center_points.append( center_point )
#cv.Circle(display_image, center_point, 10, cv.CV_RGB(255, 0, 0), 2)
#cv.Circle(display_image, center_point, 5, cv.CV_RGB(255, 0, 0), 3)
# Now we have targets that are NOT computed from bboxes -- just
# movement weights (according to kmeans). If any two targets are
# within the same "bbox count", average them into a single target.
#
# (Any kmeans targets not within a bbox are also kept.)
trimmed_center_points = []
removed_center_points = []
for box in bounding_box_list:
# Find the centers within this box:
center_points_in_box = []
for center_point in center_points:
if center_point[0] < box[right][0] and center_point[0] > box[left][0] and \
center_point[1] < box[bottom][1] and center_point[1] > box[top][1] :
# This point is within the box.
center_points_in_box.append( center_point )
# Now see if there are more than one. If so, merge them.
if len( center_points_in_box ) > 1:
# Merge them:
x_list = y_list = []
for point in center_points_in_box:
x_list.append(point[0])
y_list.append(point[1])
average_x = int( float(sum( x_list )) / len( x_list ) )
average_y = int( float(sum( y_list )) / len( y_list ) )
trimmed_center_points.append( (average_x, average_y) )
# Record that they were removed:
removed_center_points += center_points_in_box
if len( center_points_in_box ) == 1:
trimmed_center_points.append( center_points_in_box[0] ) # Just use it.
# If there are any center_points not within a bbox, just use them.
# (It's probably a cluster comprised of a bunch of small bboxes.)
for center_point in center_points:
if (not center_point in trimmed_center_points) and (not center_point in removed_center_points):
trimmed_center_points.append( center_point )
# Draw what we found:
#for center_point in trimmed_center_points:
# center_point = ( int(center_point[0]), int(center_point[1]) )
# cv.Circle(display_image, center_point, 20, cv.CV_RGB(255, 255,255), 1)
# cv.Circle(display_image, center_point, 15, cv.CV_RGB(100, 255, 255), 1)
# cv.Circle(display_image, center_point, 10, cv.CV_RGB(255, 255, 255), 2)
# cv.Circle(display_image, center_point, 5, cv.CV_RGB(100, 255, 255), 3)
# Determine if there are any new (or lost) targets:
actual_target_count = len( trimmed_center_points )
last_target_count = actual_target_count
# Now build the list of physical entities (objects)
this_frame_entity_list = []
# An entity is list: [ name, color, last_time_seen, last_known_coords ]
for target in trimmed_center_points:
# Is this a target near a prior entity (same physical entity)?
entity_found = False
entity_distance_dict = {}
for entity in last_frame_entity_list:
entity_coords= entity[3]
delta_x = entity_coords[0] - target[0]
delta_y = entity_coords[1] - target[1]
distance = sqrt( pow(delta_x,2) + pow( delta_y,2) )
entity_distance_dict[ distance ] = entity
# Did we find any non-claimed entities (nearest to furthest):
distance_list = entity_distance_dict.keys()
distance_list.sort()
for distance in distance_list:
# Yes; see if we can claim the nearest one:
nearest_possible_entity = entity_distance_dict[ distance ]
# Don't consider entities that are already claimed:
if nearest_possible_entity in this_frame_entity_list:
#print "Target %s: Skipping the one iwth distance: %d at %s, C:%s" % (target, distance, nearest_possible_entity[3], nearest_possible_entity[1] ) #Commented Out 3/20/2016
continue
#print "Target %s pixel(b,g,r) : USING the one iwth distance: %d at %s, C:%s" % (target, distance, nearest_possible_entity[3] , nearest_possible_entity[1]) # Commented Out 3/20/2016
# Found the nearest entity to claim:
entity_found = True
nearest_possible_entity[2] = frame_t0 # Update last_time_seen
nearest_possible_entity[3] = target # Update the new location
this_frame_entity_list.append( nearest_possible_entity )
#log_file.write( "%.3f MOVED %s %d %d\n" % ( frame_count, nearest_possible_entity[0], nearest_possible_entity[3][0], nearest_possible_entity[3][1] ) )
break
if entity_found == False:
# It's a new entity.
color = ( random.randint(0,255), random.randint(0,255), random.randint(0,255) )
name = hashlib.md5( str(frame_t0) + str(color) ).hexdigest()[:6]
last_time_seen = frame_t0
if imgthreshold_white[target[1],target[0]] == 0.0:
# It's a real detect (not a line marker)
new_entity = [ name, color, last_time_seen, target ]
this_frame_entity_list.append( new_entity )
log_file.write( "%.3f %.3f FOUND %s %d %d\n" % ( frame_count/fps, frame_count, new_entity[0], new_entity[3][0], new_entity[3][1] ) )
filedrive = "C:/Users/525494/New_folder/000216/run_096/"
filename = "img"+str(name)
#print "gfilter is: %.2f" + gfilter
cv.SaveImage("image-test%s-%3f.png"%(new_entity[0],gfilter), display_image)
elif imgthreshold_white[target[1],target[0]] == 255.0:
# It's a white line detect
new_entity = [ name, color, last_time_seen, target ]
this_frame_entity_list.append( new_entity )
log_file.write( "%.3f %.3f FOUND %s %d %d\n" % ( frame_count/fps, frame_count, new_entity[0], new_entity[3][0], new_entity[3][1] ) )
filedrive = "C:/Users/525494/New_folder/000216/run_096/"
filename = "img"+str(name)
#print "gfilter is: %.2f" + gfilter
cv.SaveImage("white-line-image-test%s-%3f.png"%(new_entity[0],gfilter), display_image)
elif imgthreshold_yellow[target[1],target[0]] == 255.0:
# It's a yellow line detect
new_entity = [ name, color, last_time_seen, target ]
this_frame_entity_list.append( new_entity )
log_file.write( "%.3f %.3f FOUND %s %d %d\n" % ( frame_count/fps, frame_count, new_entity[0], new_entity[3][0], new_entity[3][1] ) )
filedrive = "C:/Users/525494/New_folder/000216/run_096/"
filename = "img"+str(name)
cv.SaveImage("yellow-line-image-test%s.png"%(new_entity[0]), camera_image)
# Now "delete" any not-found entities which have expired:
entity_ttl = 1.0 # 1 sec.
for entity in last_frame_entity_list:
last_time_seen = entity[2]
if frame_t0 - last_time_seen > entity_ttl:
# It's gone.
#log_file.write( "%.3f STOPD %s %d %d\n" % ( frame_count, entity[0], entity[3][0], entity[3][1] ) )
pass
else:
# Save it for next time... not expired yet:
this_frame_entity_list.append( entity )
# For next frame:
last_frame_entity_list = this_frame_entity_list
# Draw the found entities to screen:
for entity in this_frame_entity_list:
center_point = entity[3]
c = entity[1] # RGB color tuple
cv.Circle(display_image, center_point, 20, cv.CV_RGB(c[0], c[1], c[2]), 1)
cv.Circle(display_image, center_point, 15, cv.CV_RGB(c[0], c[1], c[2]), 1)
cv.Circle(display_image, center_point, 10, cv.CV_RGB(c[0], c[1], c[2]), 2)
cv.Circle(display_image, center_point, 5, cv.CV_RGB(c[0], c[1], c[2]), 3)
#print "min_size is: " + str(min_size)
# Listen for ESC or ENTER key
c = cv.WaitKey(7) % 0x100
if c == 27 or c == 10:
break
# Toggle which image to show
if chr(c) == 'd':
image_index = ( image_index + 1 ) % len( image_list )
image_name = image_list[ image_index ]
# Display frame to user
if image_name == "camera":
image = camera_image
cv.PutText( image, "Camera (Normal)", text_coord, text_font, text_color )
elif image_name == "shadow":
image = fgmask
cv.PutText( image, "No Shadow", text_coord, text_font, text_color )
elif image_name == "white":
#image = difference
image = imgthreshold_white
cv.PutText( image, "White Threshold", text_coord, text_font, text_color )
elif image_name == "display":
#image = display_image
image = display_image
cv.PutText( image, "Targets (w/AABBs and contours)", text_coord, text_font, text_color )
cv.PutText( image, str(frame_t0), text_coord2, text_font, text_color )
cv.PutText( image, str(frame_count), text_coord3, text_font, text_color )
elif image_name == "threshold":
# Convert the image to color.
cv.CvtColor( grey_image, display_image, cv.CV_GRAY2RGB )
image = display_image # Re-use display image here
cv.PutText( image, "Motion Mask", text_coord, text_font, text_color )
elif image_name == "yellow":
# Do face detection
#detect_faces( camera_image, haar_cascade, mem_storage )
image = imgthreshold_yellow # Re-use camera image here
cv.PutText( image, "Yellow Threshold", text_coord, text_font, text_color )
#cv.ShowImage( "Target", image ) Commented out 3/19
# self.writer.write( image )
# out.write( image );
# cv.WriteFrame( self.writer, image );
# if self.writer:
# cv.WriteFrame( self.writer, image );
# video.write( image );
log_file.flush()
# If only using a camera, then there is no time.sleep() needed,
# because the camera clips us to 15 fps. But if reading from a file,
# we need this to keep the time-based target clipping correct:
frame_t1 = time.time()
# If reading from a file, put in a forced delay:
# if not self.writer:
# delta_t = frame_t1 - frame_t0
# if delta_t < ( 1.0 / 15.0 ): time.sleep( ( 1.0 / 15.0 ) - delta_t ):
if frame_count == 155740:
cv2.destroyWindow("Target")
# cv.ReleaseVideoWriter()
# self.writer.release()
# log_file.flush()
break
t1 = time.time()
time_delta = t1 - t0
processed_fps = float( frame_count ) / time_delta
print "Got %d frames. %.1f s. %f fps." % ( frame_count, time_delta, processed_fps )
#cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
# cv2.CHAIN_APPROX_SIMPLE)[-2]
# center = None
img = cv.QueryFrame(capture)
cv.Smooth(img, img, cv.CV_BLUR, 3)
hue_img = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.CvtColor(img, hue_img, cv.CV_BGR2HSV)
threshold_img = cv.CreateImage(cv.GetSize(hue_img), 8, 1)
cv.InRangeS(hue_img, (90, 115, 150), (110, 255, 255), threshold_img)
storage = cv.CreateMemStorage(0)
cnts = cv.FindContours(threshold_img,storage,cv.CV_RETR_CCOMP,\
cv.CV_CHAIN_APPROX_SIMPLE)
points = []
while cnts:
rect = cv.BoundingRect(list(cnts))
#prediksi
mode1 = clf1.predict([rect[0], rect[1]])
mode2 = clf2.predict([rect[0], rect[1]])
mode3 = clf3.predict([rect[0], rect[1]])
#angle1=clf1.predict([rect[0], rect[1]])
#angle2=clf2.predict([rect[0], rect[1]])
#angle3=clf3.predict([rect[0], rect[1]])
#angle4=clf4.predict([rect[0], rect[1]])
#angle5=clf5.predict([rect[0], rect[1]])
#print angle1, angle2, angle3, angle4, angle5
print(mode1, mode2, mode3)
teensy.write(mode1 + "M".enconde())
teensy.write(mode2 + "A".enconde()) #
teensy.write(mode3 + "I".enconde())
