def determineMarkerOrientation(self, frame):
(xm, ym) = self.lastMarkerLocation
realval = cv.Get2D(self.frameReal, ym, xm)[0]
imagval = cv.Get2D(self.frameImag, ym, xm)[0]
self.orientation = (math.atan2(-realval, imagval) -
math.pi / 2) / self.order
maxValue = 0
maxOrient = 0
searchDist = self.kernelSize / 3
for k in range(self.order):
orient = self.orientation + 2 * k * math.pi / self.order
xm2 = int(xm + searchDist * math.cos(orient))
ym2 = int(ym + searchDist * math.sin(orient))
if (xm2 > 0 and ym2 > 0 and xm2 < frame.width
and ym2 < frame.height):
try:
intensity = cv.Get2D(frame, ym2, xm2)
if (intensity[0] > maxValue):
maxValue = intensity[0]
maxOrient = orient
except:
print("determineMarkerOrientation: error: %d %d %d %d" %
(ym2, xm2, frame.width, frame.height))
pass
self.orientation = self.limitAngleToRange(maxOrient)
def determineMarkerQuality_naive(self, frame_org):
phase = np.exp((self.limitAngleToRange(-self.orientation)) * 1j)
t1_temp = self.kernelComplex * np.power(phase, self.order)
t1 = t1_temp.real > self.threshold
t2_temp = self.kernelComplex * np.power(phase, self.order)
t2 = t2_temp.real < -self.threshold
img_t1_t2_diff = t1.astype(np.float32) - t2.astype(np.float32)
angleThreshold = 3.14 / (2 * self.order)
t3 = np.angle(self.KernelRemoveArmComplex * phase) < angleThreshold
t4 = np.angle(self.KernelRemoveArmComplex * phase) > -angleThreshold
mask = 1 - 2 * (t3 & t4)
template = (img_t1_t2_diff) * mask
template = cv.fromarray(1 - template)
(xm, ym) = self.lastMarkerLocation
y1 = ym - int(math.floor(float(self.kernelSize / 2)))
y2 = ym + int(math.ceil(float(self.kernelSize / 2)))
x1 = xm - int(math.floor(float(self.kernelSize / 2)))
x2 = xm + int(math.ceil(float(self.kernelSize / 2)))
try:
frame = frame_org[y1:y2, x1:x2]
except (TypeError):
self.quality = 0
return
w, h = cv.GetSize(frame)
im_dst = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
cv.Threshold(frame, im_dst, 128, 1, cv.CV_THRESH_BINARY)
matches = 0
blacks = 0
w, h = cv.GetSize(im_dst)
for x in xrange(w):
for y in xrange(h):
if cv.Get2D(im_dst, y, x)[0] == 0: # if pixel is black
blacks += 1
if cv.Get2D(im_dst, y, x)[0] == cv.Get2D(template, y,
x)[0]:
matches += 1
else:
continue
# self.quality = float(matches)/(w*h)
self.quality = float(matches) / blacks
im_dst = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
cv.Threshold(frame, im_dst, 115, 255, cv.CV_THRESH_BINARY)
cv.ShowImage("small_image", im_dst)
cv.ShowImage("temp_kernel", template)
def getObjectHSV(event, x, y, flags, image):
# click routine on webcam input
global hsvmouse
if event == cv.CV_EVENT_LBUTTONDOWN:
pixel = cv.Get2D(hsv_image, y, x)
pixelrgb = cv.Get2D(rgb_image, y, x)
hsvmouse = pixel
print "Pixel color (HSV): "
print hsvmouse
def Color_callibration(capture):
vals = []
bgr = []
mini = [255, 255, 255]
maxi = [0, 0, 0]
cv.NamedWindow("BGR", 0)
print 'Please Put Your color in the circular area.Press ESC to start Callibration:'
while 1:
image = cv.QueryFrame(capture)
cv.Flip(image, image, 1)
cv.Circle(image, (int(200), int(300)), 10, cv.CV_RGB(255, 255, 255), 4)
cv.ShowImage("BGR", image)
c = cv.WaitKey(33)
if c == 27:
break
print 'Starting Callibration...Analyzing the Object...'
for i in range(0, 100):
image = cv.QueryFrame(capture)
cv.Flip(image, image, 1)
cv.Smooth(image, image, cv.CV_MEDIAN, 3, 0)
imagehsv = cv.CreateImage(cv.GetSize(image), 8, 3)
cv.CvtColor(image, imagehsv, cv.CV_BGR2YCrCb)
vals = cv.Get2D(imagehsv, 300, 200)
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.5, 1, 0, 2, 8)
cv.PutText(
image,
" " + str(vals[0]) + "," + str(vals[1]) + "," + str(vals[2]),
(200, 300), font, (55, 25, 255))
for j in range(0, 3):
if (vals[j] < mini[j]): mini[j] = vals[j]
if (vals[j] > maxi[j]): maxi[j] = vals[j]
cv.Circle(image, (int(200), int(300)), 10, cv.CV_RGB(255, 255, 255), 4)
cv.ShowImage("BGR", image)
c = cv.WaitKey(33)
if c == 27:
break
print 'Analyzation Completed'
mini[0] -= 35
mini[1] -= 15
mini[2] -= 15
maxi[0] += 35
maxi[1] += 15
maxi[2] += 15
for i in range(0, 3):
if (mini[i] < 0):
mini[i] = 0
if (maxi[i] > 255):
maxi[i] = 255
cv.DestroyWindow("BGR")
bgr = (mini, maxi)
return bgr
def get_color(x, y):
img = cv2.VideoCapture(-1)
img.set(3,SCREEN_WIDTH)
img.set(4,SCREEN_HIGHT)
_, bgr_image = img.read()
orig_image = bgr_image
hsv_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2HSV)
hsv_value = cv.Get2D(hsv_image,x,y)
print hsv_value
def determineMarkerQuality(self):
(xm, ym) = self.lastMarkerLocation
realval = cv.Get2D(self.frameReal, ym, xm)[0]
imagval = cv.Get2D(self.frameImag, ym, xm)[0]
realvalThirdHarmonics = cv.Get2D(self.frameRealThirdHarmonics, ym,
xm)[0]
imagvalThirdHarmonics = cv.Get2D(self.frameImagThirdHarmonics, ym,
xm)[0]
argumentPredicted = 3 * math.atan2(-realval, imagval)
argumentThirdHarmonics = math.atan2(-realvalThirdHarmonics,
imagvalThirdHarmonics)
argumentPredicted = self.limitAngleToRange(argumentPredicted)
argumentThirdHarmonics = self.limitAngleToRange(argumentThirdHarmonics)
difference = self.limitAngleToRange(argumentPredicted -
argumentThirdHarmonics)
strength = math.sqrt(realval * realval + imagval * imagval)
strengthThirdHarmonics = math.sqrt(
realvalThirdHarmonics * realvalThirdHarmonics +
imagvalThirdHarmonics * imagvalThirdHarmonics)
#print("Arg predicted: %5.2f Arg found: %5.2f Difference: %5.2f" % (argumentPredicted, argumentThirdHarmonics, difference))
#print("angdifferenge: %5.2f strengthRatio: %8.5f" % (difference, strengthThirdHarmonics / strength))
# angdifference \in [-0.2; 0.2]
# strengthRatio \in [0.03; 0.055]
self.quality = math.exp(-math.pow(difference / 0.3, 2))
def autocalibrate(orig, storage):
circles = np.asarray(storage)
#print 'drawing: ' + str(len(circles)) + ' circles'
min_value = 255
max_value = 0
s = []
for circle in circles:
Radius, x, y = int(circle[0][2]), int(circle[0][0]), int(circle[0][1])
processed = cv.CreateImage(cv.GetSize(orig), 8, 3)
cv.CvtColor(orig, processed, cv.CV_BGR2HSV)
s.append(cv.Get2D(processed, y, x))
return s
#cropped = cv.CreateImage((Radius/2,Radius/2),8,3)
#sub = cv.GetSubRect(orig,(x,y,Radius/2,Radius/2))
#cv.Copy(sub,cropped)
#cv.ShowImage('cropped',cropped)
#hist = cv.CreateHist([180], cv.CV_HIST_ARRAY, [(0,180)], 1 )
"""cv.CalcHist(cropped,hist)
def cut(disparity, image, threshold):
for i in range(0, image.height):
for j in range(0, image.width):
# keep closer object
if cv.GetReal2D(disparity, i, j) > threshold:
cv.Set2D(disparity, i, j, cv.Get2D(image, i, j))
def drop_keypoints(self, min_keypoints, outlier_threshold, mse_threshold):
sum_x = 0
sum_y = 0
sum_z = 0
sse = 0
keypoints_xy = self.keypoints
keypoints_z = self.keypoints
n_xy = len(self.keypoints)
n_z = n_xy
if self.use_depth_for_tracking:
if self.depth_image is None:
return ((0, 0, 0), 0, 0, -1)
# If there are no keypoints left to track, start over
if n_xy == 0:
return ((0, 0, 0), 0, 0, -1)
# Compute the COG (center of gravity) of the cluster
for point in self.keypoints:
sum_x = sum_x + point[0]
sum_y = sum_y + point[1]
mean_x = sum_x / n_xy
mean_y = sum_y / n_xy
if self.use_depth_for_tracking:
for point in self.keypoints:
try:
z = cv.Get2D(self.depth_image,
min(self.frame_height - 1, int(point[1])),
min(self.frame_width - 1, int(point[0])))
except:
continue
z = z[0]
# Depth values can be NaN which should be ignored
if isnan(z):
continue
else:
sum_z = sum_z + z
mean_z = sum_z / n_z
else:
mean_z = -1
# Compute the x-y MSE (mean squared error) of the cluster in the camera plane
for point in self.keypoints:
sse = sse + (point[0] - mean_x) * (point[0] - mean_x) + (
point[1] - mean_y) * (point[1] - mean_y)
#sse = sse + abs((point[0] - mean_x)) + abs((point[1] - mean_y))
# Get the average over the number of feature points
mse_xy = sse / n_xy
# The MSE must be > 0 for any sensible feature cluster
if mse_xy == 0 or mse_xy > mse_threshold:
return ((0, 0, 0), 0, 0, -1)
# Throw away the outliers based on the x-y variance
max_err = 0
for point in self.keypoints:
std_err = ((point[0] - mean_x) * (point[0] - mean_x) +
(point[1] - mean_y) * (point[1] - mean_y)) / mse_xy
if std_err > max_err:
max_err = std_err
if std_err > outlier_threshold:
keypoints_xy.remove(point)
if self.show_add_drop:
# Briefly mark the removed points in red
cv2.circle(self.marker_image, (point[0], point[1]), 3,
(0, 0, 255), cv.CV_FILLED, 2, 0)
try:
keypoints_z.remove(point)
n_z = n_z - 1
except:
pass
n_xy = n_xy - 1
# Now do the same for depth
if self.use_depth_for_tracking:
sse = 0
for point in keypoints_z:
try:
z = cv.Get2D(self.depth_image,
min(self.frame_height - 1, int(point[1])),
min(self.frame_width - 1, int(point[0])))
z = z[0]
sse = sse + (z - mean_z) * (z - mean_z)
except:
n_z = n_z - 1
if n_z != 0:
mse_z = sse / n_z
else:
mse_z = 0
# Throw away the outliers based on depth using percent error
# rather than standard error since depth values can jump
# dramatically at object boundaries
for point in keypoints_z:
try:
z = cv.Get2D(self.depth_image,
min(self.frame_height - 1, int(point[1])),
min(self.frame_width - 1, int(point[0])))
z = z[0]
except:
continue
try:
pct_err = abs(z - mean_z) / mean_z
if pct_err > self.pct_err_z:
keypoints_xy.remove(point)
if self.show_add_drop:
# Briefly mark the removed points in red
cv2.circle(self.marker_image, (point[0], point[1]),
2, (0, 0, 255), cv.CV_FILLED)
except:
pass
else:
mse_z = -1
self.keypoints = keypoints_xy
# Consider a cluster bad if we have fewer than min_keypoints left
if len(self.keypoints) < min_keypoints:
score = -1
else:
score = 1
return ((mean_x, mean_y, mean_z), mse_xy, mse_z, score)
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)
###############################
# ## Face detection stuff
# haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_default.xml' )
haar_cascade = cv.Load('E:\\Softwares\\opencv\\data\\haarcascades\\haarcascade_frontalface_alt.xml')
# haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_alt2.xml' )
# haar_cascade = cv.Load( 'haarcascades/haarcascade_mcs_mouth.xml' )
# haar_cascade = cv.Load( 'haarcascades/haarcascade_eye.xml' )
# haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_alt_tree.xml' )
# haar_cascade = cv.Load( 'haarcascades/haarcascade_upperbody.xml' )
# haar_cascade = cv.Load( 'haarcascades/haarcascade_profileface.xml' )
# Set this to the max number of targets to look for (passed to k-means):
max_targets = 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)
# 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)
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
detect_faces(camera_image, haar_cascade, mem_storage)
image2 = camera_image
cv.ShowImage("Target 1", image1)
cv.ShowImage("Target 2", image2)
# 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)
[rows, cols] = cv.GetSize(frame)
image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, frame.nChannels)
cv.Copy(frame, image)
cv.ShowImage("camera", frame)
leftImage = cv.CreateImage((image.width, image.height), 8, 1)
cv.CvtColor(image, leftImage, cv.CV_BGR2GRAY)
frame2 = cv.QueryFrame(self.capture2)
print type(frame2)
image2 = cv.CreateImage(cv.GetSize(frame2), cv.IPL_DEPTH_8U, frame2.nChannels)
cv.Copy(frame2, image2)
cv.ShowImage("camera2", frame2)
rightImage = cv.CreateImage((image2.width, image2.height), 8, 1)
cv.CvtColor(image2, rightImage, cv.CV_BGR2GRAY)
disparity_left = cv.CreateMat(leftImage.height, leftImage.width, cv.CV_16S)
disparity_right = cv.CreateMat(rightImage.height, rightImage.width, cv.CV_16S)
# data structure initialization
state = cv.CreateStereoGCState(16, 2)
# print leftImage.width
# print leftImage.height
# print rightImage.width
# print rightImage.height
# running the graph-cut algorithm
cv.FindStereoCorrespondenceGC(leftImage, rightImage, disparity_left, disparity_right, state)
disp_left_visual = cv.CreateMat(leftImage.height, leftImage.width, cv.CV_8U)
cv.ConvertScale(disparity_left, disp_left_visual, -16);
# cv.Save("disparity.pgm", disp_left_visual); # save the map
#
# cutting the object farthest of a threshold (120)
cut(disp_left_visual, leftImage, 120)
# cv.NamedWindow('Disparity map', cv.CV_WINDOW_AUTOSIZE)
cv.ShowImage('Disparity map', disp_left_visual)
#
# minimum value for the intensity
maxValue = 0
maxPoint = None
# now for all the moving object centers get the average intensity value
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)
# cv.Avg(arr)
print center_point
print type(disp_left_visual)
print size(disp_left_visual)
print center_point
print "value " + str(cv.Get2D(disp_left_visual, center_point[1], center_point[0]))
value = cv.Get2D(disp_left_visual, center_point[1], center_point[0])[0] + cv.Get2D(disp_left_visual, center_point[1], center_point[0])[1] + cv.Get2D(disp_left_visual, center_point[1], center_point[0])[2]
if value > maxValue:
maxValue = value
maxPoint = center_point
print "min value is " + str(maxValue)
print " min point is " + str(maxPoint)
if maxPoint != None:
cv.Circle(display_image, maxPoint, 17, cv.CV_RGB(100, 100, 100), 1)
#distance = 1 / maxValue
# find if it is right or left or in the middle
if maxValue > 100:
middle = width / 2
if maxPoint[0] > middle + 20:
message = "look left"
elif maxPoint[0] < middle - 20:
message = "look right"
else:
message = "look middle"
print "message " + message
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)
import cv2.cv as cv
image = cv2.imread('images/2-result_single1.jpg')
height, width, channels = image.shape
cv2.rectangle(image, (height/2 - 5, width/2 - 5), (height/2 + 5, width/2 + 5), (0, 128, 255), -1)
cv2.namedWindow('image', cv2.WINDOW_NORMAL)
cv2.imshow('image', image)
cv2.waitKey(0)
# Convert BGR to HSV
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
s=cv.Get2D(hsv, height/2, width/2)
print "H:",s[0]," S:",s[1]," V:",s[2]
H=hsv.val[0];
S=hsv.val[1];
V=hsv.val[2];
print(image[height/2, width/2])
print(hsv[height/2, width/2])
Vec3b color = image.at<Vec3b>(Point(x,y));
bgrPixel.val[0] = rowPtr[j*cn + 0]; // B
bgrPixel.val[1] = rowPtr[j*cn + 1]; // G
bgrPixel.val[2] = rowPtr[j*cn + 2]; // R
# for more details about cv.BoundingRect,see documentation
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3])
points.append(pt1)
points.append(pt2)
cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255, 0, 0), 1)
# calculating centroids
centroidx = cv.Round((pt1[0] + pt2[0]) / 2)
centroidy = cv.Round((pt1[1] + pt2[1]) / 2)
# identifying if blue blobs exist and adding centroids to corresponding lists.
# note that the lower and upper bounds correspond to the the lower and upper bounds
# in the getthresholdedimg(im): function earlier in the script.
# e.g., yellow has a lowerbound of 95 and upper bound of 115 in both sections of code
if (55 < cv.Get2D(imghsv, centroidy, centroidx)[0] < 155):
blue.append((centroidx, centroidy))
# draw colors in windows; exception handling is used to avoid IndexError.
# after drawing is over, centroid from previous part is removed from list by pop.
# so in next frame, centroids in this frame become initial points of line to draw
# draw blue box around blue blimp blob
try:
cv.Circle(imdraw, blue[1], 5, (255, 0, 0))
cv.Line(imdraw, blue[0], blue[1], (255, 0, 0), 3, 8, 0)
blue.pop(0)
print("centroid x:" + str(centroidx))
print("centroid y:" + str(centroidy))
print("")
except IndexError:
cap = cv2.VideoCapture("http://192.168.1.2:8080/videofeed?dummy=file.mjpeg")
cv.NamedWindow('HSV', cv.CV_WINDOW_AUTOSIZE)
cv.NamedWindow('HS_', cv.CV_WINDOW_AUTOSIZE)
# running the classifiers
storage = cv.CreateMemStorage()
while True:
_, frame = cap.read()
#frame = cv2.medianBlur(frame,5)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
hsv[:, :, 2] = 0
cv2.imshow('HSV', hsv)
# hsv[:,:,1] = cv2.threshold(hsv[:,:,1], 65, 255, cv2.THRESH_BINARY)
# TR_MIN = np.array([5, 50, 50],np.uint8)
# TR_MAX = np.array([15, 255, 255],np.uint8)
# frame_threshed = cv2.inRange(hsv, TR_MIN, TR_MAX)
cv.SetMouseCallback("camera", on_mouse, 0)
s = cv.Get2D(cv.fromarray(hsv), y_co, x_co)
if s[1] < 20:
hsv[:, :, 1] = 0
cv2.imshow('HS_', hsv)
print "H:", s[0], " S:", s[1], " V:", s[2]
c = cv.WaitKey(1)
if c == 27:
break
pub.publish(pub_string)
y_count = 0
print "Right Offset=", value
elif (int(x) < 190 and int(x) > 130):
value = 30
cv.PutText(frame, "Center[" + str(value) + "]",
(int(x), int(y)), font, (0, 255, 0))
pub_string = "c" + chr(int(value))
pub.publish(pub_string)
print "Center", value
cv.SetMouseCallback("result", on_mouse, 0)
if (count == 0):
s = cv.Get2D(hsv, y_co, x_co)
h1 = s[0] - 40
h2 = s[0] + 40
s1 = s[1] - 40
s2 = s[1] + 40
v1 = s[2] - 40
v2 = s[2] + 40
count = 1
# print "H1:",h1," S1:",s1," V1:",v1
# print "H2:",h2," S2:",s2," V2:",v2
contour = contour.h_next() print contour # for more details about cv.BoundingRect,see documentation pt1 = (bound_rect[0], bound_rect[1]) pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3]) points.append(pt1) points.append(pt2) cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255,0,0), 1) # Calculating centroids centroidx = cv.Round((pt1[0]+pt2[0])/2) centroidy = cv.Round((pt1[1]+pt2[1])/2) # Identifying if blue or yellow blobs and adding centroids to corresponding lists if (20 < cv.Get2D(imghsv,centroidy,centroidx)[0] < 30): yellow.append((centroidx,centroidy)) elif (100 < cv.Get2D(imghsv,centroidy,centroidx)[0] < 120): # 100 120 blue.append((centroidx,centroidy)) elif (150 < cv.Get2D(imghsv,centroidy,centroidx)[0] < 170): purple.append((centroidx,centroidy)) # Now drawing part. Exceptional handling is used to avoid IndexError. After drawing is over, centroid from previous part is # removed from list by pop. So in next frame,centroids in this frame become initial points of line to draw. try: cv.Circle(imdraw, yellow[1], 5, (0,255,255)) cv.Line(imdraw, yellow[0], yellow[1], (0,255,255), 3, 8, 0) yellow.pop(0) except IndexError: print "Just wait for yellow" try:
# UPDATED 9/22: 20 X AND Y PIXEL MINIMUM TO DRAW RED BOX AROUND BLIMP
if ypix > 20 and xpix > 20:
cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255,0,0), 1)
# calculating centroids
centroidx = cv.Round((pt1[0]+pt2[0])/2)
centroidy = cv.Round((pt1[1]+pt2[1])/2)
# identifying if blue blobs exist and adding centroids to corresponding lists.
# note that the lower and upper bounds correspond to the the lower and upper bounds
# in the getthresholdedimg(im): function earlier in the script.
# e.g., yellow has a lowerbound of 95 and upper bound of 115 in both sections of code
# UPDATED 9/22: 20 X AND Y PIXEL MINIMUM TO BE APPENDED TO CENTROID LISTS
if (55 < cv.Get2D(imghsv,centroidy,centroidx)[0] < 155) and ypix > 20 and xpix > 20:
blue.append((centroidx,centroidy))
# draw colors in windows; exception handling is used to avoid IndexError.
# after drawing is over, centroid from previous part is removed from list by pop.
# so in next frame, centroids in this frame become initial points of line to draw
# draw blue box around blue blimp blob
try:
cv.Circle(imdraw, blue[1], 5, (255,0,0))
cv.Line(imdraw, blue[0], blue[1], (255,0,0), 3, 8, 0)
print('xpix:'+str(xpix))
blue.pop(0)
print("centroid x:" + str(centroidx))
print("centroid y:" + str(centroidy))
print("")
import cv2.cv as cv
im = cv.LoadImageM("../img/alkaline.jpg")
#Access a specific pixel
print im[3, 3]
print cv.Get1D(im, 3)
print cv.Get2D(im, 3, 3) # etc..
#cv.GetND(im, [3,3,3,3]) for a 4 dimension array
col0 = cv.GetCol(im, 0) #Return the first column
cols = cv.GetCols(im, 0, 10) # Return a matrix of the ten first column
row = cv.GetRow(im, 0) #Return the first row (first pixels line)
rows = cv.GetRows(im, 0, 10) # Return the ten first rows of the image
#---------------------------
#Iterate throught pixels
red_sum = 0
green_sum = 0
blue_sum = 0
c = 0
for i in range(0, im.rows - 1):
for j in range(0, im.cols - 1):
c = c + 1
red_sum += im[i, j][0]
green_sum += im[i, j][1]
