def findImageContour(img, frame):
storage = cv.CreateMemStorage()
cont = cv.FindContours(img, storage, cv.CV_RETR_EXTERNAL,
cv.CV_CHAIN_APPROX_NONE, (0, 0))
max_center = [None, 0]
for c in contour_iterator(cont):
# Number of points must be more than or equal to 6 for cv.FitEllipse2
# Use to set minimum size of object to be tracked.
if len(c) >= 60:
# Copy the contour into an array of (x,y)s
PointArray2D32f = cv.CreateMat(1, len(c), cv.CV_32FC2)
for (i, (x, y)) in enumerate(c):
PointArray2D32f[0, i] = (x, y)
# Fits ellipse to current contour.
(center, size, angle) = cv.FitEllipse2(PointArray2D32f)
# Only consider location of biggest contour -- adapt for multiple object tracking
if size > max_center[1]:
max_center[0] = center
max_center[1] = size
angle = angle
if True:
# Draw the current contour in gray
gray = cv.CV_RGB(255, 255, 255)
cv.DrawContours(img, c, gray, gray, 0, 1, 8, (0, 0))
if max_center[1] > 0:
# Convert ellipse data from float to integer representation.
center = (cv.Round(max_center[0][0]), cv.Round(max_center[0][1]))
size = (cv.Round(max_center[1][0] * 0.5),
cv.Round(max_center[1][1] * 0.5))
color = cv.CV_RGB(255, 0, 0)
cv.Ellipse(frame, center, size, angle, 0, 360, color, 3, cv.CV_AA, 0)
def run(self):
started = time.time()
while True:
currentframe = cv.QueryFrame(self.capture)
instant = time.time() #Get timestamp o the frame
self.processImage(currentframe) #Process the image
if not self.isRecording:
if self.somethingHasMoved():
self.trigger_time = instant #Update the trigger_time
if instant > started + 10: #Wait 5 second after the webcam start for luminosity adjusting etc..
print("Something is moving !")
if self.doRecord: #set isRecording=True only if we record a video
self.isRecording = True
cv.DrawContours(currentframe, self.currentcontours,
(0, 0, 255), (0, 255, 0), 1, 2, cv.CV_FILLED)
else:
if instant >= self.trigger_time + 10: #Record during 10 seconds
print("Stop recording")
self.isRecording = False
else:
cv.PutText(currentframe,
datetime.now().strftime("%b %d, %H:%M:%S"),
(25, 30), self.font, 0) #Put date on the frame
cv.WriteFrame(self.writer, currentframe) #Write the frame
if self.show:
cv.ShowImage("Image", currentframe)
c = cv.WaitKey(1) % 0x100
if c == 27 or c == 10: #Break if user enters 'Esc'.
break
def on_trackbar(position):
# create the image for putting in it the founded contours
contours_image = cv.CreateImage((_SIZE, _SIZE), 8, 3)
# compute the real level of display, given the current position
levels = position - 3
# initialisation
_contours = contours
if levels <= 0:
# zero or negative value
# => get to the nearest face to make it look more funny
_contours = contours.h_next().h_next().h_next()
# first, clear the image where we will draw contours
cv.SetZero(contours_image)
# draw contours in red and green
cv.DrawContours(contours_image, _contours, _red, _green, levels, 3,
cv.CV_AA, (0, 0))
# finally, show the image
cv.ShowImage("contours", contours_image)
def on_trackbar(position):
# create the image for putting in it the founded contours
contours_image = cv.CreateImage((_SIZE, _SIZE), 8, 3)
# compute the real level of display, given the current position
levels = position - 3
# initialisation
_contours = contours
if levels <= 0:
# zero or negative value
# => get to the nearest face to make it look more funny
_contours = contours.h_next().h_next().h_next()
# first, clear the image where we will draw contours
cv.SetZero(contours_image)
# draw contours in red and green
cv.DrawContours(
contours_image, #dest image
_contours, #input contours
_red, #color of external contour
_green, #color of internal contour
levels, #maxlevel of contours to draw
_contour_thickness,
cv.CV_AA, #line type
(0, 0)) #offset
# finally, show the image
cv.ShowImage("contours", contours_image)
def find_rectangles(self,input_img):
""" Find contours in the input image.
input_img: Is a binary image
"""
contours_img=cv.CreateMat(input_img.height, input_img.width, cv.CV_8UC1) # Image to draw the contours
copied_img=cv.CreateMat(input_img.height, input_img.width, input_img.type) # Image to draw the contours
cv.Copy(input_img, copied_img)
contours = cv.FindContours(copied_img,cv.CreateMemStorage(),cv.CV_RETR_TREE,cv.CV_CHAIN_APPROX_SIMPLE)
cv.DrawContours(contours_img,contours,255,0,10)
return contours_img
def process_image(self, slider_pos):
"""
This function finds contours, draws them and their approximation by ellipses.
"""
stor = cv.CreateMemStorage()
# Create the destination images
image02 = cv.CloneImage(self.source_image)
cv.Zero(image02)
image04 = cv.CreateImage(cv.GetSize(self.source_image),
cv.IPL_DEPTH_8U, 3)
cv.Zero(image04)
# Threshold the source image. This needful for cv.FindContours().
cv.Threshold(self.source_image, image02, slider_pos, 255,
cv.CV_THRESH_BINARY)
# Find all contours.
cont = cv.FindContours(image02, stor, cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_NONE, (0, 0))
for c in contour_iterator(cont):
# Number of points must be more than or equal to 6 for cv.FitEllipse2
if len(c) >= 6:
# Copy the contour into an array of (x,y)s
PointArray2D32f = cv.CreateMat(1, len(c), cv.CV_32FC2)
for (i, (x, y)) in enumerate(c):
PointArray2D32f[0, i] = (x, y)
# Draw the current contour in gray
gray = cv.CV_RGB(100, 100, 100)
cv.DrawContours(image04, c, gray, gray, 0, 1, 8, (0, 0))
# Fits ellipse to current contour.
(center, size, angle) = cv.FitEllipse2(PointArray2D32f)
# Convert ellipse data from float to integer representation.
center = (cv.Round(center[0]), cv.Round(center[1]))
size = (cv.Round(size[0] * 0.5), cv.Round(size[1] * 0.5))
# Draw ellipse in random color
color = cv.CV_RGB(random.randrange(256), random.randrange(256),
random.randrange(256))
cv.Ellipse(image04, center, size, angle, 0, 360, color, 2,
cv.CV_AA, 0)
# Show image. HighGUI use.
cv.ShowImage("Result", image04)
def run(self):
started = time.time()
while True:
currentframe = cv.QueryFrame(self.capture)
instant = time.time() #Get timestamp o the frame
self.processImage(currentframe) #Process the image
if not self.isRecording:
if self.somethingHasMoved():
self.trigger_time = instant #Update the trigger_time
if instant > started + 10: #Wait 5 second after the webcam start for luminosity adjusting etc..
print datetime.now().strftime(
"%b %d, %H:%M:%S"), "Something is moving !"
os.system(
"cvlc --play-and-exit --equalizer-preamp=20 --fullscreen ./v1.mp4"
)
os.system("mv v1.mp4 vt.mp4")
os.system("mv v2.mp4 v1.mp4")
os.system("mv v3.mp4 v2.mp4")
os.system("mv v4.mp4 v3.mp4")
os.system("mv v5.mp4 v4.mp4")
os.system("mv v6.mp4 v5.mp4")
os.system("mv v7.mp4 v6.mp4")
os.system("mv v8.mp4 v7.mp4")
os.system("mv v9.mp4 v8.mp4")
os.system("mv v10.mp4 v9.mp4")
os.system("mv vt.mp4 v10.mp4")
instant = time.time() #Get timestamp o the frame
started = instant
currentframe = cv.QueryFrame(self.capture)
self.processImage(currentframe) #Process the image
print "Something is moving !"
cv.DrawContours(currentframe, self.currentcontours,
(0, 0, 255), (0, 255, 0), 1, 2, cv.CV_FILLED)
if self.show:
cv.ShowImage("Image", currentframe)
c = cv.WaitKey(1) % 0x100
if c == 27 or c == 10: #Break if user enters 'Esc'.
break
def run(self):
started = time.time()
while True:
currentframe = cv.QueryFrame(self.capture)
instant = time.time() #Get timestamp of the frame
self.processImage(currentframe) #Process the image
if not self.isRecording:
if self.somethingHasMoved():
self.trigger_time = instant #Update the trigger_time
if instant > started + 0: #Wait 5 second after the webcam start for luminosity adjusting etc..
print "Something is moving !"
#------------------------------------------------------------------- EMAIL BEGIN --------------------------------------------------------------------------
## content = 'Your House is Compromised ... run n***a run' # email
## mail = smtplib.SMTP('smtp.gmail.com',587) # email
## mail.ehlo() # email
## mail.starttls() # email
## mail.login('*****@*****.**','sanmplouzaki') # email
##
## mail.sendmail('*****@*****.**','*****@*****.**',content) # email
## mail.close() # email
#------------------------------------------------------------------- EMAIL END --------------------------------------------------------------------------
self.initRecorder()
if self.doRecord: #set isRecording=True only if we record a video
self.isRecording = True # rasfasdsd--------------------------------------------------------------------- DANGER
cv.DrawContours(currentframe, self.currentcontours,
(0, 0, 255), (0, 255, 0), 1, 2, cv.CV_FILLED)
else:
if instant >= self.trigger_time + 10: #Record during 10 seconds
print "Stop recording"
self.isRecording = False
time.sleep(8)
if self.show:
cv.ShowImage("Image", currentframe)
c = cv.WaitKey(1) % 0x100
if c == 27 or c == 10: #Break if user enters 'Esc'.
break
def on_contour(position):
# compute the real level of display, given the current position
levels = position-3
# initialisation
_contours = contours
if levels <= 0:
# zero or negative value
# => get to the nearest face to make it look more funny
_contours = contours.h_next().h_next().h_next()
# first, clear the image where we will draw contours
cv.SetZero (contours_image)
# draw contours in red and green
cv.DrawContours (contours_image, _contours,_white, _green,levels, 1, cv.CV_AA,(0, 0))
# finally, show the image
cv.ShowImage ("contours", contours_image)
def on_trackbar(position):
'''
position is the value of the track bar
'''
img_result = cv.CreateImage(src_img_size, 8, 1)
cv.Canny(img_gray, img_result, position, position*2, 3)
cv.ShowImage("contours", img_result)
storage = cv.CreateMemStorage()
contours = cv.FindContours(img_result, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE)
print contours
# draw contours in red and green
cv.DrawContours (img_result, #dest image
contours, #input contours
_red, #color of external contour
_green, #color of internal contour
levels, #maxlevel of contours to draw
_contour_thickness,
cv.CV_AA, #line type
(0, 0)) #offset
pass
def crack(tocrack,withContourImage=False):
#Function that intent to release all characters on the image so that the ocr can detect them
#We just apply 4 filters but with multiples rounds
resized = resizeImage(tocrack, (tocrack.width*6, tocrack.height*6))
dilateImage(resized, 4)
erodeImage(resized, 4)
thresholdImage(resized, 200, cv.CV_THRESH_BINARY)
if withContourImage: #If we want the image made only with contours
contours = getContours(resized, 5)
contourimage = cv.CreateImage(cv.GetSize(resized), 8, 3)
cv.Zero(contourimage)
cv.DrawContours(contourimage, contours, cv.Scalar(255), cv.Scalar(255), 2, cv.CV_FILLED)
contourimage = resizeImage(contourimage, cv.GetSize(tocrack))
resized = resizeImage(resized, cv.GetSize(tocrack))
return resized, contourimage
resized = resizeImage(resized, cv.GetSize(tocrack))
return resized
def run(self):
started = time.time()
while True:
currentframe = cv.QueryFrame(self.capture)
instant = time.time() #Get timestamp o the frame
self.processImage(currentframe) #Process the image
if self.somethingHasMoved():
self.trigger_time = instant #Update the trigger_time
if instant > started + 10: #Wait 5 second after the webcam start for luminosity adjusting etc..
# Something moved, check to see if monitor is off, if so turn it on
self.wakeMonitorIfOff()
cv.DrawContours(currentframe, self.currentcontours,
(0, 0, 255), (0, 255, 0), 1, 2, cv.CV_FILLED)
else:
# Check to see if its been specified time, if so turn off Monitor
self.checkTimeSinceLastMoved()
c = cv.WaitKey(1) % 0x100
if c == 27 or c == 10: #Break if user enters 'Esc'.
break
contours = cv.FindContours(img_grayscale, storage, cv.CV_RETR_TREE,
cv.CV_CHAIN_APPROX_SIMPLE, (0, 0))
for i in contours:
print i
contours = cv.ApproxPoly(contours, storage, cv.CV_POLY_APPROX_DP, 8, 1)
levels = 2
# first, clear the image where we will draw contours
cv.SetZero(img_contour)
# initialisation
_contours = contours
# draw contours in red and green
cv.DrawContours(
img_contour, #dest image
_contours, #input contours
_red, #color of external contour
_green, #color of internal contour
levels, #maxlevel of contours to draw
_contour_thickness,
cv.CV_AA, #line type
(0, 0)) #offset
cv.NamedWindow("contours", 1)
# finally, show the image
cv.ShowImage("contours", img_contour)
cv.WaitKey(0)
def process_image(self, slider_pos):
global cimg, source_image1, ellipse_size, maxf, maxs, eoc, lastcx, lastcy, lastr
"""
This function finds contours, draws them and their approximation by ellipses.
"""
stor = cv.CreateMemStorage()
# Create the destination images
cimg = cv.CloneImage(self.source_image)
cv.Zero(cimg)
image02 = cv.CloneImage(self.source_image)
cv.Zero(image02)
image04 = cv.CreateImage(cv.GetSize(self.source_image),
cv.IPL_DEPTH_8U, 3)
cv.Zero(image04)
# Threshold the source image. This needful for cv.FindContours().
cv.Threshold(self.source_image, image02, slider_pos, 255,
cv.CV_THRESH_BINARY)
# Find all contours.
cont = cv.FindContours(image02, stor, cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_NONE, (0, 0))
maxf = 0
maxs = 0
size1 = 0
for c in contour_iterator(cont):
if len(c) > ellipse_size:
PointArray2D32f = cv.CreateMat(1, len(c), cv.CV_32FC2)
for (i, (x, y)) in enumerate(c):
PointArray2D32f[0, i] = (x, y)
# Draw the current contour in gray
gray = cv.CV_RGB(100, 100, 100)
cv.DrawContours(image04, c, gray, gray, 0, 1, 8, (0, 0))
if iter == 0:
strng = segF + '/' + 'contour1.png'
cv.SaveImage(strng, image04)
color = (255, 255, 255)
(center, size, angle) = cv.FitEllipse2(PointArray2D32f)
# Convert ellipse data from float to integer representation.
center = (cv.Round(center[0]), cv.Round(center[1]))
size = (cv.Round(size[0] * 0.5), cv.Round(size[1] * 0.5))
if iter == 1:
if size[0] > size[1]:
size2 = size[0]
else:
size2 = size[1]
if size2 > size1:
size1 = size2
size3 = size
# Fits ellipse to current contour.
if eoc == 0 and iter == 2:
rand_val = abs((lastr - ((size[0] + size[1]) / 2)))
if rand_val > 20 and float(max(size[0], size[1])) / float(
min(size[0], size[1])) < 1.5:
lastcx = center[0]
lastcy = center[1]
lastr = (size[0] + size[1]) / 2
if rand_val > 20 and float(max(size[0], size[1])) / float(
min(size[0], size[1])) < 1.4:
cv.Ellipse(cimg, center, size, angle, 0, 360, color, 2,
cv.CV_AA, 0)
cv.Ellipse(source_image1, center, size, angle, 0, 360,
color, 2, cv.CV_AA, 0)
elif eoc == 1 and iter == 2:
(int, cntr, rad) = cv.MinEnclosingCircle(PointArray2D32f)
cntr = (cv.Round(cntr[0]), cv.Round(cntr[1]))
rad = (cv.Round(rad))
if maxf == 0 and maxs == 0:
cv.Circle(cimg, cntr, rad, color, 1, cv.CV_AA, shift=0)
cv.Circle(source_image1,
cntr,
rad,
color,
2,
cv.CV_AA,
shift=0)
maxf = rad
elif (maxf > 0 and maxs == 0) and abs(rad - maxf) > 30:
cv.Circle(cimg, cntr, rad, color, 2, cv.CV_AA, shift=0)
cv.Circle(source_image1,
cntr,
rad,
color,
2,
cv.CV_AA,
shift=0)
maxs = len(c)
if iter == 1:
temp3 = 2 * abs(size3[1] - size3[0])
if (temp3 > 40):
eoc = 1
def run(self):
# Capture first frame to get size
frame = cv.QueryFrame(self.capture)
frame_size = cv.GetSize(frame)
width = frame.width
height = frame.height
surface = width * height # Surface area of the image
cursurface = 0 # Hold the current surface that have changed
grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
moving_average = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_32F, 3)
difference = None
while True:
color_image = cv.QueryFrame(self.capture)
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3,
0) # Remove false positives
if not difference: # For the first time put values in difference, temp and moving_average
difference = cv.CloneImage(color_image)
temp = cv.CloneImage(color_image)
cv.ConvertScale(color_image, moving_average, 1.0, 0.0)
else:
cv.RunningAvg(color_image, moving_average, 0.020,
None) # Compute the average
# 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 so that it can be thresholded
cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)
cv.Threshold(grey_image, grey_image, 70, 255, cv.CV_THRESH_BINARY)
cv.Dilate(grey_image, grey_image, None, 18) # to get object blobs
cv.Erode(grey_image, grey_image, None, 10)
# Find contours
storage = cv.CreateMemStorage(0)
contours = cv.FindContours(grey_image, storage,
cv.CV_RETR_EXTERNAL,
cv.CV_CHAIN_APPROX_SIMPLE)
backcontours = contours # Save contours
while contours: # For all contours compute the area
cursurface += cv.ContourArea(contours)
contours = contours.h_next()
avg = (
cursurface * 100
) / surface # Calculate the average of contour area on the total size
if avg > self.ceil:
print("Something is moving !")
ring = IntrusionAlarm()
ring.run()
# print avg,"%"
cursurface = 0 # Put back the current surface to 0
# Draw the contours on the image
_red = (0, 0, 255)
# Red for external contours
_green = (0, 255, 0)
# Gren internal contours
levels = 1 # 1 contours drawn, 2 internal contours as well, 3 ...
cv.DrawContours(color_image, backcontours, _red, _green, levels, 2,
cv.CV_FILLED)
cv.ShowImage("Virtual Eye", color_image)
# Listen for ESC or ENTER key
c = cv.WaitKey(7) % 0x100
if c == 27 or c == 10:
break
elif c == 99:
cv2.destroyWindow('Warning!!!')
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)
orig = cv.LoadImage("robin2.png")
#Convert in black and white
res = cv.CreateImage(cv.GetSize(orig), 8, 1)
cv.CvtColor(orig, res, cv.CV_BGR2GRAY)
#Operations on the image
openCloseImage(res)
dilateImage(res, 2)
erodeImage(res, 2)
smoothImage(res, 5)
thresholdImage(res, 150, cv.CV_THRESH_BINARY_INV)
#Get contours approximated
contourLow = getContours(res, 3)
#Draw them on an empty image
final = cv.CreateImage(cv.GetSize(res), 8, 1)
cv.Zero(final)
cv.DrawContours(final, contourLow, cv.Scalar(255), cv.Scalar(255), 2,
cv.CV_FILLED)
cv.ShowImage("orig", orig)
cv.ShowImage("image", res)
cv.SaveImage("modified.png", res)
cv.ShowImage("contour", final)
cv.SaveImage("contour.png", final)
cv.WaitKey(0)
cv.MorphologyEx(im2, im2, None, element, cv.CV_MOP_CLOSE)
cv.Threshold(im2, im2, 128, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage("After MorphologyEx", im2)
# --------------------------------
vals = cv.CloneImage(
im2) #crea y clona para encontrar los contrnos de la imagen modificada
contours = cv.FindContours(vals, cv.CreateMemStorage(0), cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_SIMPLE, (0, 0))
_red = (0, 0, 255)
#contorno rojo
_green = (0, 255, 0)
#contorno verde
levels = 2 #1 dibuja un contorno o mas en este caso es 2
cv.DrawContours(orig, contours, _red, _green, levels, 2,
cv.CV_FILLED) #dibujar los contornos de color de imagenes
cv.ShowImage("Image", orig)
cv.SaveImage("Bordes imagen.png", orig)
cv.WaitKey(0)
enter = raw_input("Mostrar Borde implementado por el profesor")
epsilon = 0.5
Rho = numpy.array([
0.29677419, 0.25698324, 0.19409283, 0.36129032, 0.31284916, 0.23628692,
0.66451613, 0.57541899, 0.43459916
])
img = cv2.imread('FotopruebaLab3.png', cv2.CV_LOAD_IMAGE_COLOR)
borde = 255 * numpy.ones((480, 640), float)
for i in range(1, 479):
for j in range(1, 639):
if c == ord('w'):
storage = cv.CreateMemStorage(0)
#cv.SaveImage("wshed_mask.png", marker_mask)
#marker_mask = cv.LoadImage("wshed_mask.png", 0)
contours = cv.FindContours(marker_mask, storage, cv.CV_RETR_CCOMP,
cv.CV_CHAIN_APPROX_SIMPLE)
def contour_iterator(contour):
while contour:
yield contour
contour = contour.h_next()
cv.Zero(markers)
comp_count = 0
for c in contour_iterator(contours):
cv.DrawContours(markers, c, cv.ScalarAll(comp_count + 1),
cv.ScalarAll(comp_count + 1), -1, -1, 8)
comp_count += 1
cv.Watershed(img0, markers)
cv.Set(wshed, cv.ScalarAll(255))
# paint the watershed image
color_tab = [
(cv.RandInt(rng) % 180 + 50, cv.RandInt(rng) % 180 + 50,
cv.RandInt(rng) % 180 + 50) for i in range(comp_count)
]
for j in range(markers.height):
for i in range(markers.width):
idx = markers[j, i]
if idx != -1:
import cv2.cv as cv
orig = cv.LoadImage('meinv.jpg', cv.CV_LOAD_IMAGE_COLOR)
im = cv.CreateImage(cv.GetSize(orig), 8, 1)
cv.CvtColor(orig, im, cv.CV_BGR2GRAY)
#Keep the original in colour to draw contours in the end
cv.Threshold(im, im, 128, 255, cv.CV_THRESH_BINARY)
cv.ShowImage("Threshold 1", im)
element = cv.CreateStructuringElementEx(5*2+1, 5*2+1, 5, 5, cv.CV_SHAPE_RECT)
cv.MorphologyEx(im, im, None, element, cv.CV_MOP_OPEN) #Open and close to make appear contours
cv.MorphologyEx(im, im, None, element, cv.CV_MOP_CLOSE)
cv.Threshold(im, im, 128, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage("After MorphologyEx", im)
# --------------------------------
vals = cv.CloneImage(im) #Make a clone because FindContours can modify the image
contours=cv.FindContours(vals, cv.CreateMemStorage(0), cv.CV_RETR_LIST, cv.CV_CHAIN_APPROX_SIMPLE, (0,0))
_red = (0, 0, 255); #Red for external contours
_green = (0, 255, 0);# Gren internal contours
levels=2 #1 contours drawn, 2 internal contours as well, 3 ...
cv.DrawContours (orig, contours, _red, _green, levels, 2, cv.CV_FILLED) #Draw contours on the colour image
cv.ShowImage("Image", orig)
cv.WaitKey(0)