def draw_label(self, image):
for detect_object in self.objects:
name = detect_object.get("name", "")
color = detect_object.get("color", "")
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0.0, 2,
cv.CV_AA)
text_size, ymin = cv.GetTextSize(name, font)
for position in detect_object.get("positions"):
# confidence = position.get("confidence", 0)
# name = "%s: %d" % (name, confidence)
# name += "%"
xmin = position.get("xmin", "")
xmax = position.get("xmax", "")
ymin = position.get("ymin", "")
ymax = position.get("ymax", "")
cv2.cv.Rectangle(image, (xmin, ymin), (xmax, ymax), color, 4)
cv2.cv.Rectangle(image, (xmin, ymin - text_size[1] - 10),
(xmin + text_size[0], ymin), color,
cv.CV_FILLED)
cv2.cv.PutText(image, name, (xmin, ymin - 10), font, (0, 0, 0))
def __init__(self, videoFile, gTruthXmlFile, outputXml, platesDir):
self.xml = XmlWriter(outputXml)
self.gtruth = XmlGTruthReader(gTruthXmlFile)
self.capture = cv.CaptureFromFile(videoFile)
cv.NamedWindow("Video", cv.CV_WINDOW_AUTOSIZE)
self.w = cv.GetCaptureProperty(self.capture,
cv.CV_CAP_PROP_FRAME_WIDTH)
self.h = cv.GetCaptureProperty(self.capture,
cv.CV_CAP_PROP_FRAME_HEIGHT)
self.nFrames = cv.GetCaptureProperty(self.capture,
cv.CV_CAP_PROP_FRAME_HEIGHT)
print('Total number of Frames in video: ' + str(self.nFrames))
self.font = cv.InitFont(cv.CV_FONT_HERSHEY_PLAIN, 1, 1, 0, 1, 1)
print("resolution: " + str(int(self.w)) + "x" + str(int(self.h)))
self.fx = 0.85
self.fy = 0.85
self.iframe = self.xml.iframe
self.plate = True
self.radar = False
self.semaphore = False
self.moto = False
self.currv = None
self.mouse = MouseEvent()
self.select = PlaceSelection()
' create platesDir if needed '
self.plateCarRadar = platesDir + "/car-radar"
self.plateCarNoRad = platesDir + "/car-noradar"
self.plateMotoRadar = platesDir + "/moto-radar"
self.plateMotoNoRad = platesDir + "/moto-noradar"
if not os.path.isdir(platesDir):
os.mkdir(platesDir)
if not os.path.isdir(self.plateCarRadar):
os.mkdir(self.plateCarRadar)
if not os.path.isdir(self.plateCarNoRad):
os.mkdir(self.plateCarNoRad)
if not os.path.isdir(self.plateMotoRadar):
os.mkdir(self.plateMotoRadar)
if not os.path.isdir(self.plateMotoNoRad):
os.mkdir(self.plateMotoNoRad)
def __init__(self, threshold=70, showWindows=True):
self.writer = None
self.font = None
self.show = showWindows # Either or not show the 2 windows
self.frame = None
self.capture = cv.CaptureFromCAM(0)
self.frame = cv.QueryFrame(
self.capture) # Take a frame to init recorder
self.frame = self.frame[1:100, 540:640]
self.frame1gray = cv.CreateMat(self.frame.height, self.frame.width,
cv.CV_8U) # Gray frame at t-1
cv.CvtColor(self.frame, self.frame1gray, cv.CV_RGB2GRAY)
# Will hold the thresholded result
self.res = cv.CreateMat(self.frame.height, self.frame.width, cv.CV_8U)
self.frame2gray = cv.CreateMat(self.frame.height, self.frame.width,
cv.CV_8U) # Gray frame at t
self.width = self.frame.width
self.height = self.frame.height
self.nb_pixels = self.width * self.height
self.threshold = threshold
self.trigger_time = 0 # Hold timestamp of the last detection
codec = cv.CV_FOURCC('M', 'J', 'P', 'G') # ('W', 'M', 'V', '2')
self.writer = cv.CreateVideoWriter(
datetime.now().strftime("%b-%d_%H_%M_%S") + ".wmv", codec, 5,
cv.GetSize(self.frame), 1)
# FPS set to 5 because it seems to be the fps of my cam but should be ajusted to your needs
self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2,
8) # Creates a font
def __init__(self, camera, image_path="images"):
# 判断视频是否打开
if not camera.isOpened():
print "摄像头未打开"
exit(1)
self.image_path = image_path
if not os.path.exists(self.image_path):
os.mkdir(self.image_path)
self.camera = camera
self.fps = camera.get(cv2.cv.CV_CAP_PROP_FPS)
self.fps = self.fps if self.fps > 0 else 5
self.size = (int(camera.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)),
int(camera.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)))
print('fps:' + repr(self.fps) + ' size:' + repr(self.size))
self.es = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 4))
self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SCRIPT_SIMPLEX, 1, 1, 0, 3,
8)
self.background = None
self.last_save_at = 0
self.last_back_at = 0
self.mp4 = None
def run(fP, accAvg, threshL, ID):
# Initialize
#log_file_name = "tracker_output.log"
#log_file = file( log_file_name, 'a' )
cap = cv2.VideoCapture(fP)
# Capture the first frame from file for image properties
orig_image = cap.read()[1]
#For now, just cut off the bottom 5% ####NEEDS TO BE CHANGED
display_image = orig_image[1:700, 1:1280]
#cv2.imshow("frame",display_image)
#cv2.waitKey(1200)
#cv2.destroyWindow("frame")
#Define SubArea Based on Mouse Event
box = [0, 0, 0, 0]
## creating mouse callback function
#def my_mouse_callback(event,x,y,flags,param):
#global drawing_box
#if event==cv2.EVENT_LBUTTONDOWN:
#drawing_box=True
#[box[0],box[1],box[2],box[3]]=[x,y,0,0]
#print box[0]
#if event==cv2.EVENT_LBUTTONUP:
#drawing_box=False
#if box[2]<0:
#box[0]+=box[2]
#box[2]*=-1
#if box[3]<0:
#box[1]+=box[3]
#box[3]*=-1
#if event==cv2.EVENT_MOUSEMOVE:
#if (drawing_box==True):
#box[2]=x-box[0]
#box[3]=y-box[1]
## Function to draw the rectangle
#def draw_box(img,box):
#cv2.rectangle(img,(box[0],box[1]),(box[0]+box[2],box[1]+box[3]),(255,0,0))
## main program
#drawing_box=False
#cv2.namedWindow("Box Example")
#cv2.setMouseCallback("Box Example",my_mouse_callback,display_image)
#while(1):
#temp=display_image.copy()
#if drawing_box==True:
#draw_box(temp,box)
#cv2.imshow("Box Example",temp)
#if cv.WaitKey(20)%0x100==27:break
#cv2.destroyWindow("Box Example")
##################################################################################################
#For now, just have it ignore the bottom few rows, since that is where the time diff is being sent.
##################################################################################################
width = np.size(display_image, 1)
height = np.size(display_image, 0)
frame_size = (width, height)
# Greyscale image, thresholded to create the motion mask:
grey_image = np.uint8(display_image)
# The RunningAvg() function requires a 32-bit or 64-bit image...
running_average_image = np.float32(display_image)
# ...but the AbsDiff() function requires matching image depths:
running_average_in_display_color_depth = display_image.copy()
# RAM used by FindContours():
mem_storage = cv.CreateMemStorage(0)
# The difference between the running average and the current frame:
difference = display_image.copy()
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 = 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 = (255, 255, 255)
# Set this to the max number of targets to look for (passed to k-means):
max_targets = 1
while True:
# Capture frame from file
ret, camera_imageO = cap.read()
if not ret:
break
#For now, just cut off the bottom 5% ####NEEDS TO BE CHANGED
camera_image = camera_imageO[1:700, 1:1280]
frame_count += 1
frame_t0 = time.time()
# Create an image with interactive feedback:
display_image = camera_image.copy()
# Create a working "color image" to modify / blur
color_image = display_image.copy()
cv2.imshow("Initial", color_image)
cv2.waitKey(1200)
cv2.destroyWindow("Initial")
cv2.imwrite(
file_destination + "/" + str(frame_count) + "Initial" + ".jpg",
color_image)
# Smooth to get rid of false positives
color_image = cv2.GaussianBlur(color_image, (9, 9), 0)
cv2.imshow("Blur", color_image)
cv2.waitKey(1200)
cv2.destroyWindow("Blur")
cv2.imwrite(
file_destination + "/" + str(frame_count) + "Blur" + ".jpg",
color_image)
# 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.)
#This value is very critical.
cv2.accumulateWeighted(color_image, running_average_image, accAvg)
#cv2.imshow("frame",running_average_image)
##cv2.waitKey(100)
#cv2.destroyWindow("frame")
running_average_in_display_color_depth = cv2.convertScaleAbs(
running_average_image)
cv2.imshow("runnAVG", running_average_in_display_color_depth)
cv2.waitKey(1200)
cv2.destroyWindow("runnAVG")
# Subtract the current frame from the moving average.
difference = cv2.absdiff(color_image,
running_average_in_display_color_depth)
cv2.imshow("diff", difference)
cv2.waitKey(1200)
cv2.destroyWindow("diff")
cv2.imwrite(
file_destination + "/" + str(frame_count) + "diff" + ".jpg",
difference)
# Convert the image to greyscale.
grey_image = cv2.cvtColor(difference, cv2.COLOR_BGR2GRAY)
#cv2.imshow("Convertgray",grey_image)
#cv2.waitKey(100)
#cv2.destroyWindow("Convertgray")
# Threshold the image to a black and white motion mask:
ret, grey_image = cv2.threshold(grey_image, threshL, 255,
cv2.THRESH_BINARY)
cv2.imshow("Threshold", grey_image)
cv2.waitKey(1200)
cv2.destroyWindow("Threshold")
cv2.imwrite(
file_destination + "/" + str(frame_count) + "threshold" + ".jpg",
grey_image)
# Smooth and threshold again to eliminate "sparkles"
#grey_image = cv2.GaussianBlur(grey_image,(9,9),0)
#ret,grey_image = cv2.threshold(grey_image, 240, 255, cv2.THRESH_BINARY )
#cv2.imshow("frame",grey_image)
#cv2.waitKey(1200)
#cv2.destroyWindow("frame")
non_black_coords_array = numpy.where(grey_image > 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
contours, hierarchy = cv2.findContours(grey_image, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
if len(contours) == 0:
continue
print(len(contours))
cnt = contours[0]
len(cnt)
drawing = np.uint8(display_image)
##Draw the initial contours?
#for cnt in contours:
#bx,by,bw,bh = cv2.boundingRect(cnt)
#cv2.drawContours(drawing,[cnt],0,(0,255,0),1) # draw contours in green color
#cv2.imshow('output',drawing)
##cv2.waitKey(100)
cv2.destroyWindow("output")
for cnt in contours:
bounding_rect = cv2.boundingRect(cnt)
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 = cv2.approxPolyDP(cnt,
0.1 * cv2.arcLength(cnt, True),
True)
approx = cv2.approxPolyDP(cnt, 0.1 * cv2.arcLength(cnt, True),
True)
## 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)
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:
#print(len(trimmed_box_list))
#for box in trimmed_box_list:
#cv2.rectangle( display_image, box[0], box[1], (0,255,0), 3 )
#cv2.imshow('output',display_image)
##cv2.waitKey(100)
#cv2.destroyWindow("output")
bounding_box_list = merge_collided_bboxes(trimmed_box_list)
# Draw the merged box list:
for box in bounding_box_list:
cv2.rectangle(display_image, box[0], box[1], (0, 255, 0), 1)
cv2.imshow('output', orig_image)
cv2.waitKey(1200)
cv2.destroyWindow("output")
cv2.imwrite(
file_destination + "/" + str(frame_count) + "output" + ".jpg",
orig_image)
# 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)
cv2.circle(display_image, center_point, 10, (255, 0, 0), 2)
cv2.circle(display_image, center_point, 5, (255, 0, 0), 3)
cv2.imshow('output', orig_image)
cv2.waitKey(500)
cv2.destroyWindow("output")
# 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]) )
# cv2.circle(display_image, center_point, 20, (255, 255,255), 1)
# cv2.circle(display_image, center_point, 15, (100, 255, 255), 1)
# cv2.circle(display_image, center_point, 10, (255, 255, 255), 2)
# cv2.circle(display_image, center_point, 5,(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
cv2.circle(camera_imageO, center_point, 20, (c[0], c[1], c[2]), 1)
cv2.circle(camera_imageO, center_point, 15, (c[0], c[1], c[2]), 1)
cv2.circle(camera_imageO, center_point, 10, (c[0], c[1], c[2]), 2)
cv2.circle(camera_imageO, center_point, 5, (c[0], c[1], c[2]), 3)
cv2.imshow('output', camera_imageO)
cv2.waitKey(1200)
cv2.destroyWindow("output")
cv2.imwrite(
file_destination + "/" + str(frame_count) + "final" + ".jpg",
camera_imageO)
###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
#cv2.putText( image, "Camera (Normal)", text_coord, text_font, text_color )
#elif image_name == "difference":
#image = difference
#cv2.putText( image, "Difference Image", text_coord, text_font, text_color )
#elif image_name == "display":
#image = display_image
#cv2.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
#cv2.putText( image, "Motion Mask", text_coord, text_font, text_color )
##cv2.ShowImage( "Target", image )
#cv2.imshow("Target",image)
#cv2.waitKey(1200)
#cv2.destroyWindow("frame")
##################################################
#To Do, write to file if the center is in the box?
#If it makes it to here, write an image
cv2.imwrite(fileD + ID + "/" + str(frame_count) + ".jpg",
camera_imageO)
def run(fP, accAvg, threshL):
#Report name of file
sys.stderr.write("Processing file %s\n" % (fP))
#Define directories, here assuming that we want to append the file structure of the last three folders to the file destination
normFP = os.path.normpath(fP)
(filepath, filename) = os.path.split(normFP)
(shortname, extension) = os.path.splitext(filename)
(_, IDFL) = os.path.split(filepath)
#we want to name the output a folder from the output destination with the named extension
print("Output path will be %s/%s/%s" % (fileD, IDFL, shortname))
print("AccAvg begin value is: %s" % (accAvg))
file_destination = os.path.join(fileD, IDFL, shortname)
if not os.path.exists(file_destination):
os.makedirs(file_destination)
# Create a log file with each coordinate
log_file_name = file_destination + "/" + "tracker_output.log"
log_file = file(log_file_name, 'a')
#create hit counter to track number of outputs
hitcounter = 0
cap = cv2.VideoCapture(fP)
# Capture the first frame from file for image properties
orig_image = cap.read()[1]
###Get information about camera and image
width = np.size(orig_image, 1)
height = np.size(orig_image, 0)
frame_size = (width, height)
#For now, just cut off the bottom 5% if the timing mechanism is on the bottom.
if plotwatcher:
display_image = orig_image[1:700, 1:1280]
else:
display_image = orig_image
if vis:
cv2.imshow("frame", display_image)
cv2.waitKey(1000)
cv2.destroyWindow("frame")
width = np.size(display_image, 1)
height = np.size(display_image, 0)
frame_size = (width, height)
#Get frame rate if the plotwatcher setting hasn't been called
if plotwatcher:
frame_rate = 1
else:
frame_rate = round(cap.get(cv.CV_CAP_PROP_FPS))
#get frame time relative to start
frame_time = cap.get(cv.CV_CAP_PROP_POS_MSEC)
print("frame rate: " + str(frame_rate))
sys.stderr.write("frame rate: " + str(frame_rate))
# Greyscale image, thresholded to create the motion mask:
grey_image = np.uint8(display_image)
# The RunningAvg() function requires a 32-bit or 64-bit image...
running_average_image = np.float32(display_image)
# ...but the AbsDiff() function requires matching image depths:
running_average_in_display_color_depth = display_image.copy()
# RAM used by FindContours():
mem_storage = cv.CreateMemStorage(0)
# The difference between the running average and the current frame:
difference = display_image.copy()
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 = []
#Set time
t0 = time.time()
# 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 = (255, 255, 255)
# Set this to the max number of targets to look for (passed to k-means):
max_targets = 1
while True:
# Capture frame from file
ret, camera_imageO = cap.read()
if not ret:
break
#For now, just cut off the bottom 5% if the plotwatcher option is called.
if plotwatcher:
camera_image = camera_imageO[1:700, 1:1280]
else:
camera_image = camera_imageO
frame_count += 1
frame_t0 = time.time()
####Adaptively set the aggregate threshold, we know that about 95% of data are negatives.
#set floor flag, we can't have negative accAVG
floor = 0
if adapt:
#Every 15min, reset the agg threshold, depending on expected level of movement
#how many frames per fiteen minutes?
#Should be a integer, round it
fift = round(10 * 60 * frame_rate)
if frame_count % fift == 0:
#If the total base is fift (15min window), then assuming 99% of images are junk the threshold should be
#We've been counting frames output to file in the hitcounter
log_file.write(
str(hitcounter) + "files written in last 10minutes" + "\n")
print(
str(hitcounter) + " files written in last 10minutes" +
"\n")
if hitcounter > (fift * frameHIT):
accAvg = accAvg + .05
if hitcounter < (fift * frameHIT):
accAvg = accAvg - .025
#In my experience its much more important to drop the sensitivity, than to increase it, so i've make the adapt filter move downwards slower than upwards.
print(file_destination + str(frame_count) +
" accAvg is changed to: " + str(accAvg))
#Write change to log file
log_file.write(file_destination + str(frame_count) +
" accAvg is changed to: " + str(accAvg) + "\n")
#reset hitcoutner for another fifteen minutes
hitcounter = 0
#Build in a floor, the value can't be negative.
if accAvg < floorvalue:
floor = floor + 1
#Reset if needed.
if floor == 1:
accAvg = floorvalue
print(file_destination + str(frame_count) +
" accAvg is reset to: " + str(accAvg))
#Write change to log file
log_file.write(file_destination + str(frame_count) +
" accAvg is reset to: " + str(accAvg) +
"\n")
########################################################
# Create an image with interactive feedback:
display_image = camera_image.copy()
# Create a working "color image" to modify / blur
color_image = display_image.copy()\
if vis:
cv2.imshow("Initial", color_image)
cv2.waitKey(1000)
cv2.destroyWindow("Initial")
# Smooth to get rid of false positives
color_image = cv2.GaussianBlur(color_image, (9, 9), 0)
#cv2.imshow("Blur",color_image)
#cv2.waitKey(1000)
#cv2.destroyWindow("Blur")
# Use the Running Average as the static background
#This value is very critical.
cv2.accumulateWeighted(color_image, running_average_image, accAvg)
if vis:
cv2.imshow("frame", running_average_image)
cv2.waitKey(1000)
cv2.destroyWindow("frame")
running_average_in_display_color_depth = cv2.convertScaleAbs(
running_average_image)
if vis:
cv2.imshow("runnAVG", running_average_in_display_color_depth)
cv2.waitKey(1000)
cv2.destroyWindow("runnAVG")
# Subtract the current frame from the moving average.
difference = cv2.absdiff(color_image,
running_average_in_display_color_depth)
if vis:
cv2.imshow("diff", difference)
cv2.waitKey(1000)
cv2.destroyWindow("diff")
# Convert the image to greyscale.
grey_image = cv2.cvtColor(difference, cv2.COLOR_BGR2GRAY)
#cv2.imshow("Convertgray",grey_image)
#cv2.waitKey(1000)
#cv2.destroyWindow("Convertgray")
# Threshold the image to a black and white motion mask:
ret, grey_image = cv2.threshold(grey_image, threshL, 255,
cv2.THRESH_BINARY)
if vis:
cv2.imshow("Threshold", grey_image)
cv2.waitKey(1000)
cv2.destroyWindow("Threshold")
non_black_coords_array = numpy.where(grey_image > 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
contours, hierarchy = cv2.findContours(grey_image, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
if len(contours) == 0:
continue
#print(len(contours))
cnt = contours[0]
len(cnt)
drawing = np.uint8(display_image)
##Draw the initial contours?
#for cnt in contours:
if vis:
bx, by, bw, bh = cv2.boundingRect(cnt)
cv2.drawContours(drawing, [cnt], 0, (0, 255, 0),
1) # draw contours in green color
cv2.imshow('output', drawing)
##cv2.waitKey(100)
cv2.destroyWindow("output")
for cnt in contours:
bounding_rect = cv2.boundingRect(cnt)
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 = cv2.approxPolyDP(cnt,
0.1 * cv2.arcLength(cnt, True),
True)
approx = cv2.approxPolyDP(cnt, 0.1 * cv2.arcLength(cnt, True),
True)
# Find the average size of the bbox (targets), then
# remove any tiny bboxes (which are probably 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)
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 * .3:
trimmed_box_list.append(box)
## Draw the trimmed box list:
#print(len(trimmed_box_list))
for box in trimmed_box_list:
if vis:
cv2.rectangle(display_image, box[0], box[1], (0, 255, 0), 3)
cv2.imshow('output', display_image)
cv2.waitKey(100)
cv2.destroyWindow("output")
try:
bounding_box_list = merge_collided_bboxes(trimmed_box_list)
except Exception, e:
print 'Error:', e
print 'Box Merge Fail:'
continue
# Draw the merged box list:
for box in bounding_box_list:
cv2.rectangle(display_image, box[0], box[1], (0, 255, 0), 1)
if vis:
cv2.imshow('output', orig_image)
cv2.waitKey(1000)
cv2.destroyWindow("output")
# 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
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)
cv2.circle(display_image, center_point, 10, (255, 0, 0), 2)
cv2.circle(display_image, center_point, 5, (255, 0, 0), 3)
if vis:
cv2.imshow('output', orig_image)
cv2.waitKey(500)
cv2.destroyWindow("output")
# 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)
# 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 with 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)
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)
# 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.
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
cv2.circle(camera_imageO, center_point, 20, (c[0], c[1], c[2]), 1)
cv2.circle(camera_imageO, center_point, 15, (c[0], c[1], c[2]), 1)
cv2.circle(camera_imageO, center_point, 10, (c[0], c[1], c[2]), 2)
cv2.circle(camera_imageO, center_point, 5, (c[0], c[1], c[2]), 3)
if vis:
cv2.imshow('output', camera_imageO)
cv2.waitKey(1000)
cv2.destroyWindow("output")
#Show final image
##cv2.ShowImage( "Target", image )
if vis:
cv2.imshow("Target", camera_imageO)
cv2.waitKey(1000)
cv2.destroyWindow("frame")
##################################################
#Write image to file
cv2.imwrite(file_destination + "/" + str(frame_count) + ".jpg",
camera_imageO)
#Log the frame count and the time in video, in case user wants to check in the original
#create a time object, this relies on the frame_rate being correct!
#set seconds
sec = timedelta(seconds=int(frame_count / frame_rate))
d = datetime(1, 1, 1) + sec
log_file.write("%d %d:%d:%d " %
(int(frame_count), d.hour, d.minute, d.second) + "\n")
#If a file has been written, flush the log to read
sys.stdout.flush()
##################################################
#Have a returned counter to balance hitRate
hitcounter = hitcounter + 1
import cv2.cv as cv
image=cv.LoadImage('../img/lena.jpg', cv.CV_LOAD_IMAGE_COLOR) #Load the image
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 3, 8) #Creates a font
y = image.height / 2 # y position of the text
x = image.width / 4 # x position of the text
cv.PutText(image,"Hello World !", (x,y),font, cv.RGB(255, 255, 255)) #Draw the text
cv.ShowImage('Hello World', image) #Show the image
cv.WaitKey(0)
def draw_label(self, img, pixmapper):
pix1 = pixmapper(self.point)
cv.PutText(img, self.label, pix1,
cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1.0, 1.0),
self.colour)
def compute(playerList, video):
videoName = video
capture = cv.CaptureFromFile(videoName)
count = int(cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_COUNT))
fps = cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FPS)
width = int(cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH))
height = int(cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT))
# store the last frame
preFrame = cv.CreateImage((width, height), 8, 1)
# store the current frame
curFrame = cv.CreateImage((width, height), 8, 1)
prePyr = cv.CreateImage((height / 3, width + 8), 8, cv.CV_8UC1)
curPyr = cv.CreateImage((height / 3, width + 8), 8, cv.CV_8UC1)
numOfPlayers = len(playerList)
# store players moving distance
players = np.zeros(numOfPlayers)
# store players position of last frame
prePlayers = playerList
# store players position of current frame
curPlayers = []
img = cv.CreateImage((width, height), 8, 1)
#flag of storing player info
flagInfo = True
for f in xrange(count):
frame = cv.QueryFrame(capture)
if (flagInfo):
cv.CvtColor(frame, img, cv.CV_BGR2GRAY)
for i in range(numOfPlayers):
font = cv.InitFont(cv.CV_FONT_HERSHEY_SCRIPT_SIMPLEX, 0.4, 0.4,
0, 2, 3)
cv.PutText(
img, str(i),
(int(prePlayers[i][0][0]), int(prePlayers[i][0][1])), font,
(255, 255, 255))
cv.SaveImage(playerInfo, img)
flagInfo = False
#Convert to gray
cv.CvtColor(frame, curFrame, cv.CV_BGR2GRAY)
#Calculate the movement using the previous and the current frame using the previous points
curPlayers, status, err = cv.CalcOpticalFlowPyrLK(
preFrame, curFrame, prePyr, curPyr, prePlayers, (10, 10), 3,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03), 0)
###temp = frame
# add new distance to list
for i in range(numOfPlayers):
players[i] += getDistance(prePlayers[i], curPlayers[i])
###cv.Line(temp, (int(prePlayers[i][0]), int(prePlayers[i][1])), (int(curPlayers[i][0]), int(curPlayers[i][1])), (255,122,122),3)
###cv.ShowImage("test", temp)
###cv2.waitKey(20)
#Put the current frame preFrame
cv.Copy(curFrame, preFrame)
prePlayers = curPlayers
###cv2.destroyAllWindows()
# print distance
i = 0
f = open(recordFile, 'w')
for player in players:
i += 1
print "player", i, "running distance: ", player, "\n"
f.write("player" + str(i) + " running distance: " + str(player) +
"meters\n")
# The difference between the running average and the current frame:
difference = display_image.copy()
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 = []
#Set time
t0 = time.time()
# 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 = (255,255,255)
# Set this to the max number of targets to look for (passed to k-means):
max_targets = 1
while True:
# Capture frame from file
ret,camera_imageO = cap.read()
if not ret:
break
#For now, just cut off the bottom 5% if the plotwatcher option is called.
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)
# 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])
# cv.SegmentMotion(non_black_coords_array, None, storage, timestamp, seg_thresh)
# 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)
blink = cv.CloneImage(drawing)
if hands:
for id in hands:
cv.Circle(blink, hands[id]['current_position'], 10, hands[id]['color']['cv'], -1, cv.CV_AA, 0)
if hands[id]['drawing'] == True:
cv.Line(drawing, hands[id]['previous_position'], hands[id]['current_position'], hands[id]['color']['cv'], 10, cv.CV_AA, 0)
cv.ShowImage('Drawing', blink)
########################### MAIN ##################################
cv.NamedWindow('Video',1)
cv.MoveWindow('Video',0,0)
cv.NamedWindow('Drawing',1)
cv.MoveWindow('Drawing',720,0)
text_font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.6, 0.6, 0, 1, 4)
drawing = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 3)
cv.Set(drawing, (255.0,255.0,255.0))
cv_image = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 3)
hands = {}
buttons_size = (100, 60)
buttons = {'White': {'color': cv.CV_RGB(255,255,255), 'start': (500, 30), 'end': (500 + buttons_size[0], 30 + buttons_size[1])},
'Black': {'color': cv.CV_RGB(0,0,0), 'start': (500, 100), 'end': (500 + buttons_size[0], 100 + buttons_size[1])},
'Red': {'color': cv.CV_RGB(255,0,0), 'start': (500, 170), 'end': (500 + buttons_size[0], 170 + buttons_size[1])},
'Green': {'color': cv.CV_RGB(0,255,0), 'start': (500, 240), 'end': (500 + buttons_size[0], 240 + buttons_size[1])},
'Blue': {'color': cv.CV_RGB(0,0,255), 'start': (500, 310), 'end': (500 + buttons_size[0], 310 + buttons_size[1])},
}
ni = Context()
0x10L: "ITF",
0x20L: "EAN_13",
0x40L: "EAN_8",
0x80L: "UPC_A",
0x100L: "UPC_E",
}
title = "Dynamsoft Barcode Reader"
# Create a window with OpenCV
cv.NamedWindow(title, 1)
capture = cv.CaptureFromCAM(0)
is_saved = False
is_camera_paused = False
line_type = cv.CV_AA
font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX, 0.1, 1, 1, 1, line_type)
key_code = -1
fileName = '/home/caratred/test.jpg'
while True:
if is_camera_paused:
if not is_saved:
is_saved = True
# Capture a frame from Webcam
img = cv.QueryFrame(capture)
# fileName = 'dynamsoft_barcode_test.jpg'
# img = cv.LoadImage('dynamsoft_barcode_test.jpg')
# Save captured frame to local disk
cv.SaveImage(fileName, img)
# Decode the captured image by Dynamsoft Barcode library
FPim += 1
cv.Circle(im, (xcentre, ycentre), 10, [0, 0, 255])
for bb in tmpbb:
FNim += 1
cv.Rectangle(im, (bb[0], bb[2]), (bb[1], bb[3]),
[255, 255, 255], 1)
TP += TPim
FP += FPim
FN += FNim
if len(matchingcoords) > 0:
cv.PutText(im, 'TP=%d, FP=%d, FN=%d' % (TPim, FPim, FNim),
(11, 21),
cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.5,
0.5), (0, 0, 0))
cv.PutText(im, 'TP=%d, FP=%d, FN=%d' % (TPim, FPim, FNim),
(11, 21),
cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.5,
0.5), (255, 255, 255))
if show_images:
cv.ShowImage('result', im)
if cv.WaitKey(0) == 27:
break
print('TP=%d, FP=%d, FN=%d' % (TP, FP, FN))
precision = (TP * 1.0) / (TP + FP)
recall = (TP * 1.0) / (TP + FN)
fscore = 2 * precision * recall / (precision + recall)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from openni import *
import cv2.cv as cv
cv.NamedWindow('Video', 1)
cv.MoveWindow('Video', 0, 0)
cv.NamedWindow('Quadro', 1)
cv.MoveWindow('Quadro', 720, 0)
fonte_do_texto = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.6, 0.6, 0, 1, 4)
quadro = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 3)
cv.Set(quadro, (255.0, 255.0, 255.0))
imagem_cv = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 3)
maos = {}
traduz = {'Wave': 'Apagador', 'Click': 'Caneta'}
efeito = 'Nenhum'
ni = Context()
ni.init()
ni.open_file_recording("BothGestures.oni")
video = ni.find_existing_node(NODE_TYPE_IMAGE)
depth = ni.find_existing_node(NODE_TYPE_DEPTH)
gesture_generator = GestureGenerator()
gesture_generator.create(ni)
gesture_generator.add_gesture('Wave')
gesture_generator.add_gesture('Click')
polar = cv.CreateImage((360, 360), 8, 3)
img = cv.CreateImage((320, 240), 8, 3)
im = cv.CreateImage((320, 240), 8, 1)
rt = cv.CreateImage((320, 240), 8, 1)
lt = cv.CreateImage((320, 240), 8, 1)
lm = cv.LoadImageM("leftmask-K-2013-02-27.bmp", cv.CV_LOAD_IMAGE_GRAYSCALE)
rm = cv.LoadImageM("rightmask-K-2013-02-27.bmp", cv.CV_LOAD_IMAGE_GRAYSCALE)
cv.NamedWindow('cam')
cv.NamedWindow('left')
cv.NamedWindow('right')
cv.SetMouseCallback("cam", on_mouse)
on_mouse(cv.CV_EVENT_LBUTTONDOWN, centerX, centerY, None, None)
font = cv.InitFont(cv.CV_FONT_HERSHEY_PLAIN, 1.0, 1.0)
M = 60
while True:
img = cv.QueryFrame(capture)
cv.CvtColor(img, im, cv.CV_RGB2GRAY)
#cv.LogPolar(img, polar, (centerX, centerY), M+1, cv.CV_INTER_NN + cv.CV_WARP_FILL_OUTLIERS )
cv.And(im, lm, lt)
leftBrightness = cv.Avg(im, mask=lm)
cv.Rectangle(lt, (0, 0), (32, 32), leftBrightness, thickness=-1)
cv.PutText(lt, "%3.0f" % leftBrightness[0], (3,20), font, cv.RealScalar(0))
cv.And(im, rm, rt)
rightBrightness = cv.Avg(im, mask=rm)
for i in range(number):
pt1 = (random.randrange(-width, 2 * width),
random.randrange(-height, 2 * height))
cv.Circle(image, pt1, random.randrange(0, 300), random_color(random),
random.randrange(-1, 9), line_type, 0)
cv.ShowImage(window_name, image)
cv.WaitKey(delay)
# draw some text
for i in range(number):
pt1 = (random.randrange(-width, 2 * width),
random.randrange(-height, 2 * height))
font = cv.InitFont(random.randrange(0, 8),
random.randrange(0, 100) * 0.05 + 0.01,
random.randrange(0, 100) * 0.05 + 0.01,
random.randrange(0, 5) * 0.1,
random.randrange(0, 10), line_type)
cv.PutText(image, "Testing text rendering!", pt1, font,
random_color(random))
cv.ShowImage(window_name, image)
cv.WaitKey(delay)
# prepare a text, and get it's properties
font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX, 3, 3, 0.0, 5, line_type)
text_size, ymin = cv.GetTextSize("OpenCV forever!", font)
pt1 = ((width - text_size[0]) / 2, (height + text_size[1]) / 2)
image2 = cv.CloneImage(image)
def __init__(self):
rospy.init_node('avi2ros', anonymous=True)
self.input = rospy.get_param("~input", "")
self.output = rospy.get_param("~output", "video_output")
self.fps = rospy.get_param("~fps", 25)
self.loop = rospy.get_param("~loop", False)
self.width = rospy.get_param("~width", "")
self.height = rospy.get_param("~height", "")
self.start_paused = rospy.get_param("~start_paused", False)
self.show_viz = not rospy.get_param("~headless", False)
self.show_text = True
image_pub = rospy.Publisher(self.output, Image, queue_size=10)
rospy.on_shutdown(self.cleanup)
video = cv.CaptureFromFile(self.input)
fps = int(cv.GetCaptureProperty(video, cv.CV_CAP_PROP_FPS))
""" Bring the fps up to the specified rate """
try:
fps = int(fps * self.fps / fps)
except:
fps = self.fps
if self.show_viz:
cv.NamedWindow("AVI Video", True) # autosize the display
cv.MoveWindow("AVI Video", 650, 100)
bridge = CvBridge()
self.paused = self.start_paused
self.keystroke = None
self.restart = False
# Get the first frame to display if we are starting in the paused state.
frame = cv.QueryFrame(video)
image_size = cv.GetSize(frame)
if self.width and self.height and (self.width != image_size[0] or self.height != image_size[1]):
rospy.loginfo("Resizing! " + str(self.width) + " x " + str(self.height))
resized_frame = cv.CreateImage((self.width, self.height), frame.depth, frame.channels)
cv.Resize(frame, resized_frame)
frame = cv.CloneImage(resized_frame)
text_frame = cv.CloneImage(frame)
cv.Zero(text_frame)
while not rospy.is_shutdown():
""" Handle keyboard events """
self.keystroke = cv.WaitKey(1000 / fps)
""" Process any keyboard commands """
if 32 <= self.keystroke and self.keystroke < 128:
cc = chr(self.keystroke).lower()
if cc == 'q':
""" user has press the q key, so exit """
rospy.signal_shutdown("User hit q key to quit.")
elif cc == ' ':
""" Pause or continue the video """
self.paused = not self.paused
elif cc == 'r':
""" Restart the video from the beginning """
self.restart = True
elif cc == 't':
""" Toggle display of text help message """
self.show_text = not self.show_text
if self.restart:
#video = cv.CaptureFromFile(self.input)
print "restarting video from beginning"
cv.SetCaptureProperty(video, cv.CV_CAP_PROP_POS_AVI_RATIO, 0)
self.restart = None
if not self.paused:
frame = cv.QueryFrame(video)
if frame and self.width and self.height:
if self.width != image_size[0] or self.height != image_size[1]:
cv.Resize(frame, resized_frame)
frame = cv.CloneImage(resized_frame)
if frame == None:
if self.loop:
self.restart = True
else:
if self.show_text:
frame_size = cv.GetSize(frame)
text_font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.2, 1, 0, 1, 8)
cv.PutText(text_frame, "Keyboard commands:", (20, int(frame_size[1] * 0.6)), text_font, cv.RGB(255, 255, 0))
cv.PutText(text_frame, " ", (20, int(frame_size[1] * 0.65)), text_font, cv.RGB(255, 255, 0))
cv.PutText(text_frame, "space - toggle pause/play", (20, int(frame_size[1] * 0.72)), text_font, cv.RGB(255, 255, 0))
cv.PutText(text_frame, " r - restart video from beginning", (20, int(frame_size[1] * 0.79)), text_font, cv.RGB(255, 255, 0))
cv.PutText(text_frame, " t - hide/show this text", (20, int(frame_size[1] * 0.86)), text_font, cv.RGB(255, 255, 0))
cv.PutText(text_frame, " q - quit the program", (20, int(frame_size[1] * 0.93)), text_font, cv.RGB(255, 255, 0))
cv.Add(frame, text_frame, text_frame)
if self.show_viz:
cv.ShowImage("AVI Video", text_frame)
cv.Zero(text_frame)
try:
test = np.asarray(frame[:,:])
publishing_image = bridge.cv2_to_imgmsg(test, "bgr8")
image_pub.publish(publishing_image)
except CvBridgeError, e:
print e
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 detect(img, cascade):
rects = cascade.detectMultiScale(img, scaleFactor=1.1,
minNeighbors=3, minSize=(10, 10),
flags = cv.CV_HAAR_SCALE_IMAGE)
if len(rects) == 0:
return []
rects[:,2:] += rects[:,:2]
return rects
def draw_rects(img, rects, color):
for x1, y1, x2, y2 in rects:
cv2.rectangle(img, (x1, y1), (x2, y2), color, 2)
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, .5, .5, lineType=cv.CV_AA)
base_data_dir = 'faces/'
log_file = 'capture_log.txt'
img_ext = 'jpg'
join = os.path.join
def dirname(base_dir=base_data_dir):
""" Generate dir name in directory for the day (inside base_dir)
Dir name format: AAAA_MM_DD
If the dir do not exists, it will be created.
"""
now = datetime.datetime.now()
dir = '%02d_%02d_%02d' % (now.year, now.month, now.day)
dir = join(base_dir, dir, '')
if not os.path.exists(dir):
os.makedirs(dir)
succ = 0 #number of frames in a row that we were successful in finding the outline
tracking = 0
win_size = 5
flags = 0
detected = 0
grey = cv.CreateImage((W, H), 8, 1)
prev_grey = cv.CreateImage((W, H), 8, 1)
pyramid = cv.CreateImage((W, H), 8, 1)
prev_pyramid = cv.CreateImage((W, H), 8, 1)
ff = cv.InitFont(cv.CV_FONT_HERSHEY_PLAIN,
1,
1,
shear=0,
thickness=1,
lineType=8)
counter = 0 #global iteration counter
undetectednum = 100
stage = 1 #1: learning colors
extract = False
selected = 0
colors = [[] for i in range(6)]
hsvs = [[] for i in range(6)]
assigned = [[-1 for i in range(9)] for j in range(6)]
for i in range(6):
assigned[i][4] = i
didassignments = False
Target = cv.CreateImage(cv.GetSize(Img), cv.IPL_DEPTH_8U, 3)
Grid = cv.CreateImage(cv.GetSize(Img), cv.IPL_DEPTH_8U, 3)
Mask = cv.CreateImage(cv.GetSize(Img), cv.IPL_DEPTH_8U, 3)
Peephole = cv.CreateImage(cv.GetSize(Img), cv.IPL_DEPTH_8U, 3)
cv.Set(Mask, cv.Scalar(0x00, 0x00, 0xff))
Display = cv.CreateImage(cv.GetSize(Img), cv.IPL_DEPTH_8U, 3)
cv.Set(Grid, cv.Scalar(0, 0, 0))
Blank = cv.CreateImage(cv.GetSize(Img), cv.IPL_DEPTH_8U, 3)
cv.Set(Blank, cv.Scalar(0, 0, 0))
Hex = cv.CreateImage(cv.GetSize(Img), cv.IPL_DEPTH_8U, 3)
cv.Set(Hex, cv.Scalar(0, 0, 0))
FontSize = 1.0
Font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX,
hscale=FontSize,
vscale=1.0,
shear=0,
thickness=1,
lineType=8)
def get_pixel(x, y):
return Target[x, y][0] + Target[x, y][1] + Target[x, y][2]
# create binary printable string
def to_bin(x):
return ''.join(x & (1 << i) and '1' or '0' for i in range(7, -1, -1))
def redraw_grid():
global Grid
def initRecorder(self): #Create the recorder
codec = cv.CV_FOURCC('M', 'J', 'P', 'G')
self.writer=cv.CreateVideoWriter(datetime.now().strftime("%b-%d_%H_%M_%S")+".wmv", codec, 5, cv.GetSize(self.frame), 1)
#FPS set to 5 because it seems to be the fps of my cam but should be ajusted to your needs
self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2, 8) #Creates a font
#!/usr/bin/python
from openni import *
import cv2.cv as cv
cv.NamedWindow('Video', 1)
cv.MoveWindow('Video', 0, 0)
cv.NamedWindow('Profundidade', 1)
cv.MoveWindow('Profundidade', 650, 0)
fonte_do_texto = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.7, 0.7, 0, 2, 8)
depth_cv = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1)
imagem_cv = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 3)
ctx = Context()
ctx.init()
video = ImageGenerator()
video.create(ctx)
video.set_resolution_preset(RES_VGA)
video.fps = 30
depth = DepthGenerator()
depth.create(ctx)
depth.set_resolution_preset(RES_VGA)
depth.fps = 30
#depth.alternative_view_point_cap.set_view_point(video)
gesture_generator = GestureGenerator()
gesture_generator.create(ctx)
gesture_generator.add_gesture('Wave')
import math
'''
Find 2 D barcode based on up to 3 channel datamatrix
'''
def absnorm8(im, im8):
""" im may be any single-channel image type. Return an 8-bit version, absolute value, normalized so that max is 255 """
(minVal, maxVal, _, _) = cv.MinMaxLoc(im)
cv.ConvertScaleAbs(im, im8, 255 / max(abs(minVal), abs(maxVal)), 0)
return im8
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX,
1.0,
1.0,
thickness=2,
lineType=cv.CV_AA)
if 0:
started = time.time()
print dm_write.decode(bg.width,
bg.height,
buffer(bg.tostring()),
max_count=1,
min_edge=12,
max_edge=13,
shape=DataMatrix.DmtxSymbol10x10) # , timeout = 10)
print "took", time.time() - started
class DmtxFinder:
import pyautogui
import cv2
import cv2.cv as cv
#using opencv1.0 functions
camera = cv.CaptureFromCAM(0)
#initializing font, color and variables
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.5, 1, 0, 2, 8)
color = (0, 0, 0)
point1 = (300, 200)
point2 = (400, 300)
flag = 0
while True:
#grabbing a frame, applying blur, flipping the image
frame = cv.QueryFrame(camera)
cv.Smooth(frame, frame, cv.CV_BLUR, 3)
cv.Flip(frame, frame, 1)
#drawing the rectangle and writing the text
temp1 = cv.CloneImage(frame)
cv.Rectangle(temp1, point1, point2, color, 1)
cv.PutText(temp1, "Place in box", (430, 240), font, color)
cv.PutText(temp1, "then hit q", (430, 260), font, color)
#taking snapshot after q is pressed
if cv.WaitKey(10) == 113:
flag = 1
cv.SetImageROI(temp1, (300, 200, 100, 100))
template = cv.CloneImage(temp1)
def initRecorder(self): #Create the recorder
codec = cv.CV_FOURCC('D', 'I', 'V', 'X')
#codec = cv.CV_FOURCC("D", "I", "B", " ")
self.writer=cv.CreateVideoWriter(datetime.now().strftime("%b-%d_%H:%M:%S")+".avi", codec, 15, cv.GetSize(self.frame), 1)
#FPS set at 15 because it seems to be the fps of my cam but should be ajusted to your needs
self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2, 8) #Creates a font
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.imwrite("7.jpg", dst)
# LPLS ruihua
img = cv2.imread("test.jpg")
gray_lap = cv2.Laplacian(img, cv2.CV_16S, ksize=3)
dst2 = cv2.convertScaleAbs(gray_lap)
cv2.imshow('laplacian', dst2)
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.imwrite("8.jpg", dst2)
# add number
#cv.CV_WINDOW_AUTOSIZE这个参数设定显示窗口虽图片大小自动变化
cv.NamedWindow('You need to struggle', cv.CV_WINDOW_AUTOSIZE)
image = cv.LoadImage('test.jpg')
#创建一个矩形，来让我们在图片上写文字，参数依次定义了文字类型，高，宽，字体厚度等。。
font = cv.InitFont(cv.CV_FONT_HERSHEY_SCRIPT_SIMPLEX, 1, 1, 0, 3, 8)
#将文字框加入到图片中，(5,20)定义了文字框左顶点在窗口中的位置，最后参数定义文字颜色
cv.PutText(image, "3160602004", (30, 30), font, (255, 0, 0))
cv.ShowImage('You need to struggle', image)
cv.WaitKey(0)
cv.SaveImage('9.jpg', image)
subject = str(input("Subject: "))
video = str(input("Video: "))
if (os.path.isfile('data/' + subject + '/' + video +
'/diagnostics.txt')) == True:
print(
"Diagnostics file exists! System will not overwrite without deleting it first."
)
sys.exit()
cv.NamedWindow("camera", 1)
capture = cv.CreateCameraCapture(0)
f = open('data/' + subject + '/' + video + '/diagnostics.txt', 'w')
#font = cv.CvFont
font = cv.InitFont(1, 1, 1, 1, 1, 1)
width = None
height = None
width = 320
height = 240
if width is None:
width = int(cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH))
else:
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH, width)
if height is None:
height = int(cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT))
else:
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT, height)
def sd_loop(self):
"""
The main seizure detector loop - call this function to start
the seizure detector.
"""
self.timeSeries = [] # array of times that data points were collected.
self.maxFreq = None
if (self.X11):
cv.NamedWindow('Seizure_Detector', cv.CV_WINDOW_AUTOSIZE)
cv.CreateTrackbar('FeatureTrackbar', 'Seizure_Detector', 0,
self.MAX_COUNT, self.onTrackbarChanged)
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.5, 0.5, 0, 1, 8)
# Intialise the video input source
# ('camera' - may be a file or network stream though).
#camera = cv.CaptureFromFile("rtsp://192.168.1.18/live_mpeg4.sdp")
#camera = cv.CaptureFromFile("../testcards/testcard.mpg")
#camera = cv.CaptureFromFile("/home/graham/laura_sample.mpeg")
camera = cv.CaptureFromCAM(0)
# Set the VideoWriter that produces the output video file.
frameSize = (640, 480)
videoFormat = cv.FOURCC('p', 'i', 'm', '1')
# videoFormat = cv.FOURCC('l','m','p','4')
vw = cv.CreateVideoWriter(self.videoOut, videoFormat, self.outputfps,
frameSize, 1)
if (vw == None):
print "ERROR - Failed to create VideoWriter...."
# Get the first frame.
last_analysis_time = datetime.datetime.now()
last_feature_search_time = datetime.datetime.now()
last_frame_time = datetime.datetime.now()
frame = cv.QueryFrame(camera)
print "frame="
print frame
# Main loop - repeat forever
while 1:
# Carry out initialisation, memory allocation etc. if necessary
if self.image is None:
self.image = cv.CreateImage(cv.GetSize(frame), 8, 3)
self.image.origin = frame.origin
grey = cv.CreateImage(cv.GetSize(frame), 8, 1)
prev_grey = cv.CreateImage(cv.GetSize(frame), 8, 1)
pyramid = cv.CreateImage(cv.GetSize(frame), 8, 1)
prev_pyramid = cv.CreateImage(cv.GetSize(frame), 8, 1)
# self.features = []
# copy the captured frame to our self.image object.
cv.Copy(frame, self.image)
# create a grey version of the image
cv.CvtColor(self.image, grey, cv.CV_BGR2GRAY)
# Look for features to track.
if self.need_to_init:
#cv.ShowImage ('loop_grey',grey)
self.initFeatures(grey)
self.timeSeries = []
self.maxFreq = None
last_analysis_time = datetime.datetime.now()
self.need_to_init = False
# Now track the features, if we have some.
if self.features != []:
# we have points to track, so track them and add them to
# our time series of positions.
self.features, status, track_error = cv.CalcOpticalFlowPyrLK(
prev_grey, grey, prev_pyramid, pyramid, self.features,
(self.win_size, self.win_size), 3,
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03),
self.flags)
self.timeSeries.append((last_frame_time, self.features))
print "Features..."
for featNo in range(len(self.features)):
if (status[featNo] == 0):
self.features[featNo] = (-1, -1)
print status[featNo], self.features[featNo]
# and plot them.
for featNo in range(len(self.features)):
pointPos = self.features[featNo]
cv.Circle(self.image, (int(pointPos[0]), int(pointPos[1])),
3, (0, 255, 0, 0), -1, 8, 0)
if (self.alarmActive[featNo] == 2):
cv.Circle(self.image,
(int(pointPos[0]), int(pointPos[1])), 10,
(0, 0, 255, 0), 5, 8, 0)
if (self.alarmActive[featNo] == 1):
cv.Circle(self.image,
(int(pointPos[0]), int(pointPos[1])), 10,
(0, 0, 255, 0), 2, 8, 0)
# there will be no maxFreq data until we have
# run doAnalysis for the first time.
if (not self.maxFreq == None):
msg = "%d-%3.1f" % (featNo, self.maxFreq[featNo])
cv.PutText(
self.image, msg,
(int(pointPos[0] + 5), int(pointPos[1] + 5)), font,
(255, 255, 255))
# end of for loop over features
else:
#print "Oh no, no features to track, and you haven't told me to look for more."
# no features, so better look for some more...
self.need_to_init = True
# Is it time to analyse the captured time series.
if ((datetime.datetime.now() - last_analysis_time).total_seconds()
> self.Analysis_Period):
if (len(self.timeSeries) > 0):
self.doAnalysis()
self.doAlarmCheck()
last_analysis_time = datetime.datetime.now()
else:
# print "Not doing analysis - no time series data..."
a = True
# Is it time to re-acquire the features to track.
if ((datetime.datetime.now() -
last_feature_search_time).total_seconds() >
self.Feature_Search_Period):
print "resetting..."
last_feature_search_time = datetime.datetime.now()
self.need_to_init = True
# save current data for use next time around.
prev_grey, grey = grey, prev_grey
prev_pyramid, pyramid = pyramid, prev_pyramid
# we can now display the image
if (self.X11): cv.ShowImage('Seizure_Detector', self.image)
cv.WriteFrame(vw, self.image)
# handle events
c = cv.WaitKey(10)
if c == 27:
# user has press the ESC key, so exit
break
# Control frame rate by pausing if we are going too fast.
frameTime = (datetime.datetime.now() - last_frame_time)\
.total_seconds()
actFps = 1.0 / frameTime
if (frameTime < 1 / self.inputfps):
cv.WaitKey(1 + int(1000. * (1. / self.inputfps - frameTime)))
# Grab the next frame
last_frame_time = datetime.datetime.now()
frame = cv.QueryFrame(camera)
