def repeat():
global capture #declare as globals since we are assigning to them now
global camera_index
global done
frame = cv.QueryFrame(capture)
cv.Smooth(frame, frame, cv.CV_GAUSSIAN, 3, 3)
imgHsv = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.CvtColor(frame, imgHsv, cv.CV_BGR2HSV)
#imgHsv2 = GetThresholdedImage(imgHsv)
#print(numpy.asarray(cv.GetMat(imgHsv)))
imgRGBA = cv.CreateImage(cv.GetSize(frame), 8, 4)
cv.CvtColor(frame, imgRGBA, cv.CV_BGR2RGBA)
cv.Smooth(imgRGBA, imgRGBA, cv.CV_GAUSSIAN, 3, 3)
(filteredImg, offsetX, offsetY) = parallelSumRed(imgRGBA, 640,
480) #3D array
d = numpy.sqrt(offsetX * offsetX + offsetY * offsetY)
if d != 0:
print("Distance = " + str(c1 / d + c2) + "cm")
print("OffsetX = " + str(offsetX) + "; OffsetY = " + str(offsetY))
print("")
imgRGB = cv.CreateImage(cv.GetSize(frame), 8, 3)
#cv.CvtColor(Image.fromarray(filteredImg), imgRGB, cv.CV_RGBA2RGB)
imgRGBA = cv.fromarray(numpy.reshape(filteredImg, (480, 640, 4)))
if offsetX != 0 or offsetY != 0:
cv.Rectangle(imgRGBA, (320 + offsetX - 6, 240 + offsetY - 6),
(320 + offsetX + 6, 240 + offsetY + 6),
(255, 0, 255, 255), 1, 8)
cv.Line(imgRGBA, (0, 240 + offsetY), (639, 240 + offsetY),
(255, 0, 255, 255), 1, 8)
cv.Line(imgRGBA, (320 + offsetX, 0), (320 + offsetX, 479),
(255, 0, 255, 255), 1, 8)
cv.ShowImage(HSVWindow, imgRGBA)
cv.ShowImage(original, frame)
cv.SetMouseCallback(original, onMouseMove, [
cv.CV_EVENT_MOUSEMOVE,
numpy.asarray(cv.GetMat(imgHsv)),
numpy.asarray(cv.GetMat(frame))
])
#cv.SetMouseCallback(HSVWindow, onMouseMove, [cv.CV_EVENT_MOUSEMOVE, numpy.asarray(cv.GetMat(imgHsv)), numpy.asarray(cv.GetMat(frame))])
#cv.ShowImage(filtered, imgHsv2)
c = cv.WaitKey(10)
if (str(c) == "27"): #if ESC is pressed
print("Thank You!")
done = True
if (str(c) == "99"): #'c' for calibration
calibration(int(input("How many data points: ")))
def get_image(camera, filename=None):
im = cv.QueryFrame(camera)
# take greyscale and compute RMS value
im2 = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 3)
cv.Convert(im, im2)
gray = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 1)
cv.CvtColor(im2, gray, cv.CV_RGB2GRAY)
gray_mat = cv.GetMat(gray)
img = numpy.asarray(gray_mat)
power = numpy.sqrt(numpy.mean(img**2))
#save file
if filename:
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 0.8, 0.8, 0, 2,
cv.CV_AA)
cv.PutText(im, filename, (DATE_X, DATE_Y), font, cv.RGB(255, 255, 0))
filename = os.path.join(DIR_PREFIX, filename + '.jpg')
print filename
cv.SaveImage(filename, im)
del font
else:
filename = ''
#del(camera)
del im, im2, gray, img, gray_mat
return (power, filename)
def genFeatres(img_list):
network = slminit()
filenames = img_list
index = 0
faceVectors = []
for img in filenames:
entry1 = img
src1 = cv.LoadImageM(entry1)
gray_full1 = cv.CreateImage(cv.GetSize(src1), 8, 1)
grayim1 = cv.CreateImage((200, 200), 8, 1)
cv.CvtColor(src1, gray_full1, cv.CV_BGR2GRAY)
cv.Resize(gray_full1, grayim1, interpolation=cv.CV_INTER_CUBIC)
gray1 = cv.GetMat(grayim1)
im_array1 = np.asarray(gray1).astype('f')
# -- compute feature map, shape [height, width, depth]
f_map1 = slmprop(im_array1, network)
f_map_dims1 = f_map1.shape
image_vector = []
for j in range(f_map_dims1[0]):
for k in range(f_map_dims1[1]):
for l in range(f_map_dims1[2]):
image_vector.append(f_map1[j][k][l])
print index
index = index + 1
faceVectors.append(np.asarray(image_vector))
return faceVectors
def getMat(self):
hdc = win32gui.GetWindowDC(self.hwnd)
dc_obj = win32ui.CreateDCFromHandle(hdc)
memorydc = dc_obj.CreateCompatibleDC()
data_bitmap = win32ui.CreateBitmap()
data_bitmap.CreateCompatibleBitmap(dc_obj, self.width, self.height)
memorydc.SelectObject(data_bitmap)
memorydc.BitBlt((0, 0), (self.width, self.height), dc_obj, (self.dx, self.dy), win32con.SRCCOPY)
bmpheader = struct.pack("LHHHH", struct.calcsize("LHHHH"),
self.width, self.height, 1, 24)
c_bmpheader = ctypes.create_string_buffer(bmpheader)
# padded_length = (string_length + 3) & -3 for 4-byte aligned.
c_bits = ctypes.create_string_buffer(" " * (self.width * ((self.height * 3 + 3) & -3)))
res = ctypes.windll.gdi32.GetDIBits(memorydc.GetSafeHdc(), data_bitmap.GetHandle(),
0, self.height, c_bits, c_bmpheader, win32con.DIB_RGB_COLORS)
win32gui.DeleteDC(hdc)
win32gui.ReleaseDC(self.hwnd, hdc)
memorydc.DeleteDC()
win32gui.DeleteObject(data_bitmap.GetHandle())
cv_im = cv.CreateImageHeader((self.width, self.height), cv.IPL_DEPTH_8U, 3)
cv.SetData(cv_im, c_bits.raw)
# flip around x-axis
cv.Flip(cv_im, None, 0)
mat = cv.GetMat(cv_im)
return numpy.asarray(mat)
def resize(self, frame):
img = cv.GetMat(frame)
for _ in range(self.resize_num):
w, h = cv.GetSize(img)
small = cv.CreateMat((h + 1) / 2, (w + 1) / 2, img.type)
cv.PyrDown(img, small)
img = cv.CreateMat((h + 1) / 2, (w + 1) / 2, img.type)
cv.Copy(small, img)
return small
def test():
#start = time.time()
src1 = cv.GetMat(cv.LoadImage("d1.png", 0))
src2 = cv.GetMat(cv.LoadImage("d2.png", 0))
pt1 = (100, 100)
pt2 = (200, 200)
crop1 = src1[pt1[1]:pt2[1], pt1[0]:pt2[0]]
crop2 = src2[pt1[1]:pt2[1], pt1[0]:pt2[0]]
#cv2.GetMat
hist1 = compute_histogram(crop1)
hist2 = compute_histogram(crop2)
sc = cv.CompareHist(hist1, hist2, cv.CV_COMP_CHISQR)
print sc
def calculate_laser_position(img):
print "calculating moments"
moments = cv.Moments(cv.GetMat(img))
posX = -1
posY = -1
area = cv.GetCentralMoment(moments, 0, 0)
if area > 0:
moment10 = cv.GetSpatialMoment(moments, 1, 0)
moment01 = cv.GetSpatialMoment(moments, 0, 1)
posX = int(moment10 / area)
posY = int(moment01 / area)
return posX, posY, area
def getAverageOpticalFlow(self, image, binary_mask):
avgLength = self.distance(self.avgX, self.avgY)
print "avg length " + str(avgLength)
step = 5
(w, h, channels) = np.shape(image)
motionCanvas = np.zeros((w, h, channels), np.uint8)
# motionCanvas2 = np.ones((w, h, channels), np.uint8)
# cv2.polylines(motionCanvas, self.lines, 0, (0, 255, 0))
for (x1, y1), (x2, y2) in self.lines:
length = self.euclideanDistance(x1, y1, x2, y2)
# print "length " + str(length)
if length > 0.8: # avgLength * 40:
cv2.line(motionCanvas, (x1, y1), (x2, y2), (255, 255, 255))
# cv2.circle(motionCanvas, (x1, y1), 1, (0, 255, 0), -1)
# cv2.line(motionCanvas, (0, 0), (100, 100), (0, 255, 0), 5)
cv2.imshow("motion", motionCanvas)
print type(binary_mask)
# (w, h) = cv.GetSize(binary_mask)
# zerosArray = np.zeros((h, w), np.uint8, 3)
if binary_mask != None:
maskMat = cv.GetMat(binary_mask)
#
# (w, h) = cv.GetSize(binary_mask)
# maskMat2 = cv.CreateMat(w, h, cv.CV_8UC3)
# cv.CvtColor(maskMat, maskMat2, cv.CV_GRAY2BGR)
maskArray = np.asarray(maskMat, np.uint8, 3)
#
motionCanvas2 = np.copy(motionCanvas)
print "size of input image " + str(np.shape(maskArray)) + " " + str(np.shape(motionCanvas2))
#
# print type(motionCanvas) , np.shape(motionCanvas)
# print type(maskArray) , np.shape(maskArray)
motionCanvas2 = cv2.bitwise_and(motionCanvas2, motionCanvas2, mask=maskArray)
# motionCanvas2 = cv2.add(motionCanvas, zerosArray, motionCanvas2, maskArray)
cv2.imshow("motion 2 ", motionCanvas2)
self.opticalPath.findPath(motionCanvas2)
def main():
# captured image size, change to whatever you want
width = 320
height = 240
capture = cv.CreateCameraCapture(0)
# Over-write default captured image size
cv.SetCaptureProperty(capture,cv.CV_CAP_PROP_FRAME_WIDTH,width)
cv.SetCaptureProperty(capture,cv.CV_CAP_PROP_FRAME_HEIGHT,height)
cv.NamedWindow( "output", 1 )
cv.NamedWindow( "processed", 1 )
while True:
frame = cv.QueryFrame(capture)
cv.Smooth(frame, frame, cv.CV_BLUR, 3)
imgColorProcessed = ColorProcess(frame)
mat = cv.GetMat(imgColorProcessed)
# Calculating the moments
moments = cv.Moments(mat, 0)
area = cv.GetCentralMoment(moments, 0, 0)
moment10 = cv.GetSpatialMoment(moments, 1, 0)
moment01 = cv.GetSpatialMoment(moments, 0,1)
# Finding a big enough blob
if(area > 60000):
# Calculating the center postition of the blob
posX = int(moment10 / area)
posY = int(moment01 / area)
# check slave status and send coordinates
state = readData()
if state == 1:
sendData(posX)
sendData(posY)
print 'x: ' + str(posX) + ' y: ' + str(posY)
# update video windows
cv.ShowImage("processed", imgColorProcessed)
cv.ShowImage("output", frame)
if cv.WaitKey(10) >= 0:
break
return;
def defineRegionOfInterest(self, image, pt1, pt2):
x0 = pt1[0]
y0 = pt1[1]
x1 = pt2[0]
y1 = pt2[1]
self.selection = (x0, y0, x1, y1)
image_mat = cv.GetMat(image)
image_array = np.asarray(image_mat, np.uint8, 3)
self.processObjectOfInterest(image_array)
if self.returnToDetection:
return
def run(self):
while True:
img = cv.QueryFrame(self.capture)
#blur the source image to reduce color noise
cv.Smooth(img, img, cv.CV_BLUR, 3)
#convert the image to hsv(Hue, Saturation, Value) so its
#easier to determine the color to track(hue)
hsv_img = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.CvtColor(img, hsv_img, cv.CV_BGR2HSV)
#limit all pixels that don't match our criteria, in this case we are
#looking for purple but if you want you can adjust the first value in
#both turples which is the hue range(120,140). OpenCV uses 0-180 as
#a hue range for the HSV color model
thresholded_img = cv.CreateImage(cv.GetSize(hsv_img), 8, 1)
cv.InRangeS(hsv_img, (120, 80, 80), (140, 255, 255),
thresholded_img)
#determine the objects moments and check that the area is large
#enough to be our object
moments = cv.Moments(cv.GetMat(thresholded_img), 0)
area = cv.GetCentralMoment(moments, 0, 0)
#there can be noise in the video so ignore objects with small areas
if (area > 10000):
#determine the x and y coordinates of the center of the object
#we are tracking by dividing the 1, 0 and 0, 1 moments by the area
x = cv.GetSpatialMoment(moments, 1, 0) / area
y = cv.GetSpatialMoment(moments, 0, 1) / area
#print 'x: ' + str(x) + ' y: ' + str(y) + ' area: ' + str(area)
#create an overlay to mark the center of the tracked object
overlay = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.Circle(overlay, (int(x), int(y)), 2, (255, 255, 255), 20)
#cv.Add(img, overlay, img)
#add the thresholded image back to the img so we can see what was
#left after it was applied
#cv.Merge(thresholded_img, None, None, None, img)
#display the image
cv.ShowImage(color_tracker_window, img)
if cv.WaitKey(10) == 27:
break
def DoBinarizeRegion(self, brightness, contrast):
#print brightness, contrast
self.UpdateLabelOfInterest()
PilImage2 = self.OriginalScreenshot.copy()
x = self.AlexaAppImages[self.AppObjectFeedbackIndex].RectX + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionX
y = self.AlexaAppImages[self.AppObjectFeedbackIndex].RectY + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionY
w = self.AlexaAppImages[self.AppObjectFeedbackIndex].RectX + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionX + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionWidth
h = self.AlexaAppImages[self.AppObjectFeedbackIndex].RectY + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionY + self.AlexaAppImages[self.AppObjectFeedbackIndex].CropRegionHeight
box = (x, y, w, h)
region = PilImage2.crop(box)
#region.save("c:\\region.png")
enhancer = ImageEnhance.Brightness(region)
region = enhancer.enhance(brightness)
enhancer = ImageEnhance.Contrast(region)
region = enhancer.enhance(contrast)
#PilImage2.paste(region, box)
cv_im = cv.CreateImageHeader(region.size, cv.IPL_DEPTH_8U, 3)
cv.SetData(cv_im, region.tostring())
mat = cv.GetMat(cv_im)
img = numpy.asarray(mat)
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
thresh = 100
im_bw = cv2.threshold(gray_image, thresh, 255, cv2.THRESH_BINARY)[1]
im = Image.fromarray(im_bw)
PilImage2.paste(im, box)
self.QtImage1 = ImageQt.ImageQt(PilImage2)
self.QtImage2 = QImage(self.QtImage1)
self.pixmap = QPixmap.fromImage(self.QtImage2)
#self.pixmap.load("im_bw.png")
self.update()
def align(path, landmarks):
x0, y0, x1, y1, x2, y2, x3, y3 = landmarks
src = cv2.imread(path, 1)
src, pl = pad_image(src)
e0 = np.array([x0 + pl, y0 + pl])
e1 = np.array([x1 + pl, y1 + pl])
m0 = np.array([x2 + pl, y2 + pl])
m1 = np.array([x3 + pl, y3 + pl])
xx = e1 - e0
yy = (e0 + e1) / 2. - (m0 + m1) / 2.
c = (e0 + e1) / 2. - 0.1 * yy
s = np.max((4. * LA.norm(xx), 3.6 * LA.norm(yy)))
s = int(s)
yy90 = np.array([yy[1], -yy[0]])
x = xx - yy90
angle = np.arctan(x[1] / x[0])
res = subimage(src, c, angle, s, s)
mat = cv.GetMat(res)
res = np.asarray(mat)
return res
self.color_and_expand_pixel(row, col, expansion_width)
else:
self.img[row][col] = np.array([255, 255, 255])
def color_and_expand_pixel(self, row, col, n=1):
width, height, t = self.color_img.shape
if not (row <= n or row >= (width - n) or col <= n or col >=
(height - n)):
for i in range(-n, n + 1):
for j in range(-n, n + 1):
self.img[row + i][col + j] = np.array(self.pen_color)
if __name__ == "__main__":
vid = cv.CaptureFromFile('vid2.mov')
img = cv.QueryFrame(vid)
while img:
print 'loopin!'
tmp = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.CvtColor(img, tmp, cv.CV_BGR2RGB)
img = np.asarray(cv.GetMat(tmp))
print 'got the image as a numpy array'
cl = ColorLapse(img, [50, 200, 50])
cv2.namedWindow(cl.window)
cv2.imshow(cl.window, cl.color_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
img = cv.QueryFrame(vid)
def run(self):
# Initialize
log_file_name = "tracker_output.log"
log_file = open( log_file_name, 'a' )
#fps = 25
#cap = cv2.VideoCapture( '../000104-.avi'
frame = cv.QueryFrame( self.capture )
frame_size = cv.GetSize( frame )
foreground = cv.CreateImage(cv.GetSize(frame),8,1)
foremat = cv.GetMat(foreground)
Nforemat = numpy.array(foremat, dtype=numpy.float32)
gfilter=sys.argv[2]
gfilter_string=gfilter
gfilter=float(gfilter)
print "Processing Tracker with filter: " + str(gfilter)
# Capture the first frame from webcam for image properties
display_image = cv.QueryFrame( self.capture )
# Create Background Subtractor
fgbg = cv2.BackgroundSubtractorMOG()
# Greyscale image, thresholded to create the motion mask:
grey_image = cv.CreateImage( cv.GetSize(frame), cv.IPL_DEPTH_8U, 1 )
# The RunningAvg() function requires a 32-bit or 64-bit image...
running_average_image = cv.CreateImage( cv.GetSize(frame), cv.IPL_DEPTH_32F, 3 )
# ...but the AbsDiff() function requires matching image depths:
running_average_in_display_color_depth = cv.CloneImage( display_image )
# RAM used by FindContours():
mem_storage = cv.CreateMemStorage(0)
# The difference between the running average and the current frame:
difference = cv.CloneImage( display_image )
target_count = 1
last_target_count = 1
last_target_change_t = 0.0
k_or_guess = 1
codebook=[]
frame_count=0
last_frame_entity_list = []
fps = 25
t0 = 165947
# For toggling display:
image_list = [ "camera", "shadow", "white", "threshold", "display", "yellow" ]
image_index = 0 # Index into image_list
# Prep for text drawing:
text_font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX, .5, .5, 0.0, 1, cv.CV_AA )
text_coord = ( 5, 15 )
text_color = cv.CV_RGB(255,255,255)
text_coord2 = ( 5, 30 )
text_coord3 = ( 5, 45 )
###############################
### Face detection stuff
#haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_default.xml' )
#haar_cascade = cv.Load( 'C:/OpenCV2.2/data/haarcascades/haarcascade_frontalface_alt.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_alt2.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_mcs_mouth.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_eye.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_frontalface_alt_tree.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_upperbody.xml' )
#haar_cascade = cv.Load( 'haarcascades/haarcascade_profileface.xml' )
# Set this to the max number of targets to look for (passed to k-means):
max_targets = 20
while True:
# Capture frame from webcam
camera_image = cv.QueryFrame( self.capture )
#ret, frame = cap.read()
frame_count += 1
frame_t0 = time.time()
mat = cv.GetMat(camera_image)
Nmat = numpy.array(mat, dtype=numpy.uint8)
# Create an image with interactive feedback:
display_image = cv.CloneImage( camera_image )
# NEW INSERT - FGMASK
fgmask = fgbg.apply(Nmat,Nforemat,-1)
fgmask = cv.fromarray(fgmask)
# Create a working "color image" to modify / blur
color_image = cv.CloneImage( display_image )
# Smooth to get rid of false positives
cv.Smooth( color_image, color_image, cv.CV_GAUSSIAN, 19, 0 ) #Changed from 19 AND MADE MEDIAN FILTER
# Smooth to get rid of false positives
# color_image = numpy.asarray( cv.GetMat( color_image ) )
# (mu, sigma) = cv2.meanStdDev(color_image)
# edges = cv2.Canny(color_image, mu - sigma, mu + sigma)
# lines = cv2.HoughLines(edges, 1, pi / 180, 70)
# Use the Running Average as the static background
# a = 0.020 leaves artifacts lingering way too long.
# a = 0.320 works well at 320x240, 15fps. (1/a is roughly num frames.)
cv.RunningAvg( color_image, running_average_image, gfilter, None )
# Convert the scale of the moving average.
cv.ConvertScale( running_average_image, running_average_in_display_color_depth, 1.0, 0.0 )
# Subtract the current frame from the moving average.
cv.AbsDiff( color_image, running_average_in_display_color_depth, difference )
# Convert the image to greyscale.
cv.CvtColor( difference, grey_image, cv.CV_RGB2GRAY )
# Smooth Before thresholding
cv.Smooth( grey_image, grey_image, cv.CV_GAUSSIAN, 19, 19 )
# Threshold the image to a black and white motion mask:
cv.Threshold( grey_image, grey_image, 2, 255, cv.CV_THRESH_BINARY )
# Smooth and threshold again to eliminate "sparkles"
#cv.Smooth( grey_image, grey_image, cv.CV_GAUSSIAN, 19, 0 ) #changed from 19 - AND put smooth before threshold
cv.Threshold( grey_image, grey_image, 240, 255, cv.CV_THRESH_BINARY)
grey_image_as_array = numpy.asarray( cv.GetMat( grey_image ) )
non_black_coords_array = numpy.where( grey_image_as_array > 3 )
# Convert from numpy.where()'s two separate lists to one list of (x, y) tuples:
non_black_coords_array = zip( non_black_coords_array[1], non_black_coords_array[0] )
frame_hsv = cv.CreateImage(cv.GetSize(color_image),8,3)
cv.CvtColor(color_image,frame_hsv,cv.CV_BGR2HSV)
imgthreshold_yellow=cv.CreateImage(cv.GetSize(color_image),8,1)
imgthreshold_white=cv.CreateImage(cv.GetSize(color_image),8,1)
imgthreshold_white2=cv.CreateImage(cv.GetSize(color_image),8,1)
cv.InRangeS(frame_hsv,cv.Scalar(0,0,196),cv.Scalar(255,255,255),imgthreshold_white) # changed scalar from 255,15,255 to 255,255,255
cv.InRangeS(frame_hsv,cv.Scalar(41,43,224),cv.Scalar(255,255,255),imgthreshold_white2)
cv.InRangeS(frame_hsv,cv.Scalar(20,100,100),cv.Scalar(30,255,255),imgthreshold_yellow)
#cvCvtColor(color_image, yellowHSV, CV_BGR2HSV)
#lower_yellow = np.array([10, 100, 100], dtype=np.uint8)
#upper_yellow = np.array([30, 255, 255], dtype=np.uint8)
#mask_yellow = cv2.inRange(yellowHSV, lower_yellow, upper_yellow)
#res_yellow = cv2.bitwise_and(color_image, color_image, mask_yellow = mask_yellow)
points = [] # Was using this to hold either pixel coords or polygon coords.
bounding_box_list = []
# Now calculate movements using the white pixels as "motion" data
contour = cv.FindContours( grey_image, mem_storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE )
i=0
while contour:
# c = contour[i]
# m = cv2.moments(c)
# Area = m['m00']
# print( Area )
bounding_rect = cv.BoundingRect( list(contour) )
point1 = ( bounding_rect[0], bounding_rect[1] )
point2 = ( bounding_rect[0] + bounding_rect[2], bounding_rect[1] + bounding_rect[3] )
bounding_box_list.append( ( point1, point2 ) )
polygon_points = cv.ApproxPoly( list(contour), mem_storage, cv.CV_POLY_APPROX_DP )
# To track polygon points only (instead of every pixel):
#points += list(polygon_points)
# Draw the contours:
###cv.DrawContours(color_image, contour, cv.CV_RGB(255,0,0), cv.CV_RGB(0,255,0), levels, 3, 0, (0,0) )
cv.FillPoly( grey_image, [ list(polygon_points), ], cv.CV_RGB(255,255,255), 0, 0 )
cv.PolyLine( display_image, [ polygon_points, ], 0, cv.CV_RGB(255,255,255), 1, 0, 0 )
#cv.Rectangle( display_image, point1, point2, cv.CV_RGB(120,120,120), 1)
# if Area > 3000:
# cv2.drawContours(imgrgb,[cnt],0,(255,255,255),2)
# print(Area)
i=i+1
contour = contour.h_next()
# Find the average size of the bbox (targets), then
# remove any tiny bboxes (which are prolly just noise).
# "Tiny" is defined as any box with 1/10th the area of the average box.
# This reduces false positives on tiny "sparkles" noise.
box_areas = []
for box in bounding_box_list:
box_width = box[right][0] - box[left][0]
box_height = box[bottom][0] - box[top][0]
box_areas.append( box_width * box_height )
#cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(255,0,0), 1)
average_box_area = 0.0
if len(box_areas): average_box_area = float( sum(box_areas) ) / len(box_areas)
trimmed_box_list = []
for box in bounding_box_list:
box_width = box[right][0] - box[left][0]
box_height = box[bottom][0] - box[top][0]
# Only keep the box if it's not a tiny noise box:
if (box_width * box_height) > average_box_area*0.1: trimmed_box_list.append( box )
# Draw the trimmed box list:
#for box in trimmed_box_list:
# cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(0,255,0), 2 )
bounding_box_list = merge_collided_bboxes( trimmed_box_list )
# Draw the merged box list:
for box in bounding_box_list:
cv.Rectangle( display_image, box[0], box[1], cv.CV_RGB(0,255,0), 1 )
# Here are our estimate points to track, based on merged & trimmed boxes:
estimated_target_count = len( bounding_box_list )
# Don't allow target "jumps" from few to many or many to few.
# Only change the number of targets up to one target per n seconds.
# This fixes the "exploding number of targets" when something stops moving
# and the motion erodes to disparate little puddles all over the place.
if frame_t0 - last_target_change_t < .35: # 1 change per 0.35 secs
estimated_target_count = last_target_count
else:
if last_target_count - estimated_target_count > 1: estimated_target_count = last_target_count - 1
if estimated_target_count - last_target_count > 1: estimated_target_count = last_target_count + 1
last_target_change_t = frame_t0
# Clip to the user-supplied maximum:
estimated_target_count = min( estimated_target_count, max_targets )
# The estimated_target_count at this point is the maximum number of targets
# we want to look for. If kmeans decides that one of our candidate
# bboxes is not actually a target, we remove it from the target list below.
# Using the numpy values directly (treating all pixels as points):
points = non_black_coords_array
center_points = []
if len(points):
# If we have all the "target_count" targets from last frame,
# use the previously known targets (for greater accuracy).
k_or_guess = max( estimated_target_count, 1 ) # Need at least one target to look for.
if len(codebook) == estimated_target_count:
k_or_guess = codebook
#points = vq.whiten(array( points )) # Don't do this! Ruins everything.
codebook, distortion = vq.kmeans( array( points ), k_or_guess )
# Convert to tuples (and draw it to screen)
for center_point in codebook:
center_point = ( int(center_point[0]), int(center_point[1]) )
center_points.append( center_point )
#cv.Circle(display_image, center_point, 10, cv.CV_RGB(255, 0, 0), 2)
#cv.Circle(display_image, center_point, 5, cv.CV_RGB(255, 0, 0), 3)
# Now we have targets that are NOT computed from bboxes -- just
# movement weights (according to kmeans). If any two targets are
# within the same "bbox count", average them into a single target.
#
# (Any kmeans targets not within a bbox are also kept.)
trimmed_center_points = []
removed_center_points = []
for box in bounding_box_list:
# Find the centers within this box:
center_points_in_box = []
for center_point in center_points:
if center_point[0] < box[right][0] and center_point[0] > box[left][0] and \
center_point[1] < box[bottom][1] and center_point[1] > box[top][1] :
# This point is within the box.
center_points_in_box.append( center_point )
# Now see if there are more than one. If so, merge them.
if len( center_points_in_box ) > 1:
# Merge them:
x_list = y_list = []
for point in center_points_in_box:
x_list.append(point[0])
y_list.append(point[1])
average_x = int( float(sum( x_list )) / len( x_list ) )
average_y = int( float(sum( y_list )) / len( y_list ) )
trimmed_center_points.append( (average_x, average_y) )
# Record that they were removed:
removed_center_points += center_points_in_box
if len( center_points_in_box ) == 1:
trimmed_center_points.append( center_points_in_box[0] ) # Just use it.
# If there are any center_points not within a bbox, just use them.
# (It's probably a cluster comprised of a bunch of small bboxes.)
for center_point in center_points:
if (not center_point in trimmed_center_points) and (not center_point in removed_center_points):
trimmed_center_points.append( center_point )
# Draw what we found:
#for center_point in trimmed_center_points:
# center_point = ( int(center_point[0]), int(center_point[1]) )
# cv.Circle(display_image, center_point, 20, cv.CV_RGB(255, 255,255), 1)
# cv.Circle(display_image, center_point, 15, cv.CV_RGB(100, 255, 255), 1)
# cv.Circle(display_image, center_point, 10, cv.CV_RGB(255, 255, 255), 2)
# cv.Circle(display_image, center_point, 5, cv.CV_RGB(100, 255, 255), 3)
# Determine if there are any new (or lost) targets:
actual_target_count = len( trimmed_center_points )
last_target_count = actual_target_count
# Now build the list of physical entities (objects)
this_frame_entity_list = []
# An entity is list: [ name, color, last_time_seen, last_known_coords ]
for target in trimmed_center_points:
# Is this a target near a prior entity (same physical entity)?
entity_found = False
entity_distance_dict = {}
for entity in last_frame_entity_list:
entity_coords= entity[3]
delta_x = entity_coords[0] - target[0]
delta_y = entity_coords[1] - target[1]
distance = sqrt( pow(delta_x,2) + pow( delta_y,2) )
entity_distance_dict[ distance ] = entity
# Did we find any non-claimed entities (nearest to furthest):
distance_list = entity_distance_dict.keys()
distance_list.sort()
for distance in distance_list:
# Yes; see if we can claim the nearest one:
nearest_possible_entity = entity_distance_dict[ distance ]
# Don't consider entities that are already claimed:
if nearest_possible_entity in this_frame_entity_list:
#print "Target %s: Skipping the one iwth distance: %d at %s, C:%s" % (target, distance, nearest_possible_entity[3], nearest_possible_entity[1] ) #Commented Out 3/20/2016
continue
#print "Target %s pixel(b,g,r) : USING the one iwth distance: %d at %s, C:%s" % (target, distance, nearest_possible_entity[3] , nearest_possible_entity[1]) # Commented Out 3/20/2016
# Found the nearest entity to claim:
entity_found = True
nearest_possible_entity[2] = frame_t0 # Update last_time_seen
nearest_possible_entity[3] = target # Update the new location
this_frame_entity_list.append( nearest_possible_entity )
#log_file.write( "%.3f MOVED %s %d %d\n" % ( frame_count, nearest_possible_entity[0], nearest_possible_entity[3][0], nearest_possible_entity[3][1] ) )
break
if entity_found == False:
# It's a new entity.
color = ( random.randint(0,255), random.randint(0,255), random.randint(0,255) )
name = hashlib.md5( str(frame_t0) + str(color) ).hexdigest()[:6]
last_time_seen = frame_t0
if imgthreshold_white[target[1],target[0]] == 0.0:
# It's a real detect (not a line marker)
new_entity = [ name, color, last_time_seen, target ]
this_frame_entity_list.append( new_entity )
log_file.write( "%.3f %.3f FOUND %s %d %d\n" % ( frame_count/fps, frame_count, new_entity[0], new_entity[3][0], new_entity[3][1] ) )
filedrive = "C:/Users/525494/New_folder/000216/run_096/"
filename = "img"+str(name)
#print "gfilter is: %.2f" + gfilter
cv.SaveImage("image-test%s-%3f.png"%(new_entity[0],gfilter), display_image)
elif imgthreshold_white[target[1],target[0]] == 255.0:
# It's a white line detect
new_entity = [ name, color, last_time_seen, target ]
this_frame_entity_list.append( new_entity )
log_file.write( "%.3f %.3f FOUND %s %d %d\n" % ( frame_count/fps, frame_count, new_entity[0], new_entity[3][0], new_entity[3][1] ) )
filedrive = "C:/Users/525494/New_folder/000216/run_096/"
filename = "img"+str(name)
#print "gfilter is: %.2f" + gfilter
cv.SaveImage("white-line-image-test%s-%3f.png"%(new_entity[0],gfilter), display_image)
elif imgthreshold_yellow[target[1],target[0]] == 255.0:
# It's a yellow line detect
new_entity = [ name, color, last_time_seen, target ]
this_frame_entity_list.append( new_entity )
log_file.write( "%.3f %.3f FOUND %s %d %d\n" % ( frame_count/fps, frame_count, new_entity[0], new_entity[3][0], new_entity[3][1] ) )
filedrive = "C:/Users/525494/New_folder/000216/run_096/"
filename = "img"+str(name)
cv.SaveImage("yellow-line-image-test%s.png"%(new_entity[0]), camera_image)
# Now "delete" any not-found entities which have expired:
entity_ttl = 1.0 # 1 sec.
for entity in last_frame_entity_list:
last_time_seen = entity[2]
if frame_t0 - last_time_seen > entity_ttl:
# It's gone.
#log_file.write( "%.3f STOPD %s %d %d\n" % ( frame_count, entity[0], entity[3][0], entity[3][1] ) )
pass
else:
# Save it for next time... not expired yet:
this_frame_entity_list.append( entity )
# For next frame:
last_frame_entity_list = this_frame_entity_list
# Draw the found entities to screen:
for entity in this_frame_entity_list:
center_point = entity[3]
c = entity[1] # RGB color tuple
cv.Circle(display_image, center_point, 20, cv.CV_RGB(c[0], c[1], c[2]), 1)
cv.Circle(display_image, center_point, 15, cv.CV_RGB(c[0], c[1], c[2]), 1)
cv.Circle(display_image, center_point, 10, cv.CV_RGB(c[0], c[1], c[2]), 2)
cv.Circle(display_image, center_point, 5, cv.CV_RGB(c[0], c[1], c[2]), 3)
#print "min_size is: " + str(min_size)
# Listen for ESC or ENTER key
c = cv.WaitKey(7) % 0x100
if c == 27 or c == 10:
break
# Toggle which image to show
if chr(c) == 'd':
image_index = ( image_index + 1 ) % len( image_list )
image_name = image_list[ image_index ]
# Display frame to user
if image_name == "camera":
image = camera_image
cv.PutText( image, "Camera (Normal)", text_coord, text_font, text_color )
elif image_name == "shadow":
image = fgmask
cv.PutText( image, "No Shadow", text_coord, text_font, text_color )
elif image_name == "white":
#image = difference
image = imgthreshold_white
cv.PutText( image, "White Threshold", text_coord, text_font, text_color )
elif image_name == "display":
#image = display_image
image = display_image
cv.PutText( image, "Targets (w/AABBs and contours)", text_coord, text_font, text_color )
cv.PutText( image, str(frame_t0), text_coord2, text_font, text_color )
cv.PutText( image, str(frame_count), text_coord3, text_font, text_color )
elif image_name == "threshold":
# Convert the image to color.
cv.CvtColor( grey_image, display_image, cv.CV_GRAY2RGB )
image = display_image # Re-use display image here
cv.PutText( image, "Motion Mask", text_coord, text_font, text_color )
elif image_name == "yellow":
# Do face detection
#detect_faces( camera_image, haar_cascade, mem_storage )
image = imgthreshold_yellow # Re-use camera image here
cv.PutText( image, "Yellow Threshold", text_coord, text_font, text_color )
#cv.ShowImage( "Target", image ) Commented out 3/19
# self.writer.write( image )
# out.write( image );
# cv.WriteFrame( self.writer, image );
# if self.writer:
# cv.WriteFrame( self.writer, image );
# video.write( image );
log_file.flush()
# If only using a camera, then there is no time.sleep() needed,
# because the camera clips us to 15 fps. But if reading from a file,
# we need this to keep the time-based target clipping correct:
frame_t1 = time.time()
# If reading from a file, put in a forced delay:
# if not self.writer:
# delta_t = frame_t1 - frame_t0
# if delta_t < ( 1.0 / 15.0 ): time.sleep( ( 1.0 / 15.0 ) - delta_t ):
if frame_count == 155740:
cv2.destroyWindow("Target")
# cv.ReleaseVideoWriter()
# self.writer.release()
# log_file.flush()
break
t1 = time.time()
time_delta = t1 - t0
processed_fps = float( frame_count ) / time_delta
print "Got %d frames. %.1f s. %f fps." % ( frame_count, time_delta, processed_fps )
def getImageCol(file):
img = cv.LoadImage(file, cv.CV_LOAD_IMAGE_GRAYSCALE)
npArr = np.array(np.asarray(cv.GetMat(img)))
npArr = np.ndarray.flatten(npArr)
return np.reshape(npArr, (npArr.shape[0], 1))
cv.WaitKey(0)
break
cv.Smooth(frame, frame, cv.CV_BLUR, 3)
hsv = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.CvtColor(frame, hsv, cv.CV_BGR2HSV)
thr = cv.CreateImage(cv.GetSize(frame), 8, 1)
#Change threshold value
cv.InRangeS(hsv, (h1, s1, v1), (h2, s2, v2), thr)
moments = cv.Moments(cv.GetMat(thr, 1), 0)
area = cv.GetCentralMoment(moments, 0, 0)
cv.Line(frame, (160, 0), (160, 240), (0, 0, 255), 3, 8, 0)
if (area > 10000):
x = cv.GetSpatialMoment(moments, 1, 0) / area
y = cv.GetSpatialMoment(moments, 0, 1) / area
# overlay = cv.CreateImage(cv.GetSize(frame),8,3)
cv.Circle(frame, (int(x), int(y)), 2, (255, 255, 255), 20)
# cv.Add(frame,overlay,frame)
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)
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)
cv.ShowImage("image", self.dst_image)
cv.CalcArrHist([self.dst_image], self.hist)
(min_value, max_value, _, _) = cv.GetMinMaxHistValue(self.hist)
cv.Scale(self.hist.bins, self.hist.bins, float(self.hist_image.height) / max_value, 0)
cv.Set(self.hist_image, cv.ScalarAll(255))
bin_w = round(float(self.hist_image.width) / hist_size)
for i in range(hist_size):
cv.Rectangle(self.hist_image, (int(i * bin_w), self.hist_image.height),
(int((i + 1) * bin_w), self.hist_image.height - cv.Round(self.hist.bins[i])),
cv.ScalarAll(0), -1, 8, 0)
cv.ShowImage("histogram", self.hist_image)
if __name__ == "__main__":
# Load the source image.
if len(sys.argv) > 1:
src_image = cv.GetMat(cv.LoadImage(sys.argv[1], 0))
else:
url = 'https://code.ros.org/svn/opencv/trunk/opencv/samples/c/baboon.jpg'
filedata = urllib2.urlopen(url).read()
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1)
cv.SetData(imagefiledata, filedata, len(filedata))
src_image = cv.DecodeImageM(imagefiledata, 0)
dh = DemHist(src_image)
cv.WaitKey(0)
def findBrightObjects(self):
cv.NamedWindow("camera")
while True :
frame = cv.QueryFrame(self.video1)
# print type(frame)
[rows, cols] = cv.GetSize(frame)
# image = cv.CreateMat(rows, cols, cv.CV_8UC3)
image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, frame.nChannels)
cv.Copy(frame, image)
# image = cv.GetMat(frame)
cv.ShowImage("camera", image)
# grayScaleFullImage = cv.CreateImage((image.width, image.height), 8, 1)
# cv.CvtColor(image, grayScaleFullImage, cv.CV_BGR2GRAY)
# convert to hsv
hsvImage = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, frame.nChannels)
cv.CvtColor(image, hsvImage, cv.CV_BGR2HSV)
cv.ShowImage("hsv", hsvImage)
# hsvImage = cv2.cvtColor(imageArray, cv.CV_BGR2HSV)
# h_plane = cv.CreateImage(cv.GetSize(image), 8, 1)
# s_plane = cv.CreateImage(cv.GetSize(image), 8, 1)
# v_plane = cv.CreateImage(cv.GetSize(image), 8, 1)
# Split HSV into two of it's three channels. V channel is same as greyscale image so ignore.
# cv.Split(hsvImage, h_plane, s_plane, v_plane, None)
# http://robbierickman.blogspot.co.uk/2011/11/laserduckpy-coloured-object-tracking.html
# planes = [h_plane, s_plane]
#
# h_bins = 30
# s_bins = 32
# hist_size = [h_bins, s_bins]
# # hue varies from 0 (~0 deg red) to 180 (~360 deg red again */
# h_ranges = [0, 180]
# # saturation varies from 0 (black-gray-white) to
# # 255 (pure spectrum color)
# s_ranges = [0, 255]
# ranges = [h_ranges, s_ranges]
# scale = 10
# hist = cv.CreateHist([h_bins, s_bins], cv.CV_HIST_ARRAY, ranges, 1)
# cv.CalcHist([cv.GetImage(i) for i in planes], hist)
# (_, max_value, _, _) = cv.GetMinMaxHistValue(hist)
#
# hist_img = cv.CreateImage((h_bins*scale, s_bins*scale), 8, 3)
#
# for h in range(h_bins):
# for s in range(s_bins):
# bin_val = cv.QueryHistValue_2D(hist, h, s)
# intensity = cv.Round(bin_val * 255 / max_value)
# cv.Rectangle(hist_img,
# (h*scale, s*scale),
# ((h+1)*scale - 1, (s+1)*scale - 1),
# cv.RGB(intensity, intensity, intensity),
# cv.CV_FILLED)
# http://uvhar.googlecode.com/hg/test/laser_tracker.py
# Threshold ranges of HSV components.
# cv.InRangeS(h_plane, hmin, hmax, h_plane)
# # cv.InRangeS(s_plane, smin, smax, s_plane)
# # cv.InRangeS(v_plane, vmin, vmax, v_plane)
#
# finalImage = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
#
# # Perform an AND on HSV components to identify the laser!
# cv.And(h_plane, s_plane, finalImage)
# # This actually Worked OK for me without using Saturation.
# # cv.cvAnd(laser_img, s_img,laser_img)
#
# # Merge the HSV components back together.
# cv.Merge(h_plane, s_plane, v_plane, None, hsvImage)
# cv.ShowImage("hue", h_plane)
# cv.ShowImage("saturation", s_plane)
# cv.ShowImage("value", v_plane)
thresholdImage = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
cv.InRangeS(hsvImage, cv.Scalar(0, 100, 100), cv.Scalar(50, 255, 255), thresholdImage)
# thresholdImage = cv2.threshold(hsvImage, [0, 100, 100], [50, 255, 255], cv2.THRESH_BINARY)
cv.ShowImage("threshold image", thresholdImage)
# remove noise from threshold image
kernel = cv.CreateStructuringElementEx(9, 9, 5, 5, cv.CV_SHAPE_CROSS)
# Dilate- replaces pixel value with highest value pixel in kernel
cv.Dilate(thresholdImage, thresholdImage, kernel, 2)
# Erode- replaces pixel value with lowest value pixel in kernel
cv.Erode(thresholdImage, thresholdImage, kernel, 2)
# element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
# cv.Dilate(thresholdImage, element, thresholdImage)
# cv2.erode(thresholdImage, element, thresholdImage)
cv.ShowImage("cleaned image ", thresholdImage)
# contour detection
imageArray = np.asarray(cv.GetMat(thresholdImage), np.uint8, 1)
print type(imageArray)
imageArray = imageArray.T
# contours, hier = cv2.findContours(imageArray, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# print "TYPE " + str(type(contours)) + " " + str(len(contours))
#
# # for i in contours:
# # print i
# maxArea = -1
# contourIndex = -1
# if contours:
# for i in range(0, len(contours)):
# cnt = contours[i].astype('int')
# print type(cnt)
# area = cv2.contourArea(cnt)
# print area
# if area > maxArea:
# maxArea = area
# contourIndex = i
#
# if contourIndex != -1:
# cv2.drawContours(imageArray, contours, contourIndex, (0, 0 , 255), 10)
params = cv2.SimpleBlobDetector_Params()
# params.minDistBetweenBlobs = 1.0 # minimum 10 pixels between blobs
# params.filterByArea = True # filter my blobs by area of blob
# params.minArea = 5.0 # min 20 pixels squared
# params.maxArea = 500.0 # max 500 pixels squared
params.minDistBetweenBlobs = 50.0
params.filterByInertia = False
params.filterByConvexity = False
params.filterByColor = False
params.filterByCircularity = False
params.filterByArea = True
params.minArea = 20.0
params.maxArea = 500.0
myBlobDetector = cv2.SimpleBlobDetector(params)
keypoints = myBlobDetector.detect(imageArray)
print "blobs " + str(keypoints)
# extract the x y coordinates of the keypoints:
for i in range(0, len(keypoints) - 1):
print keypoints[i].pt
pt1 = (int(keypoints[i].pt[0]), int(keypoints[i].pt[1]))
pt2 = (int(keypoints[i + 1].pt[0]), int(keypoints[i + 1].pt[1]))
cv2.line(imageArray, pt1, pt2, (255, 0, 0))
# float X=keypoints[i].pt.x;
# float Y=keypoints[i].pt.y;
cv2.imshow("final detection ", imageArray)
#
if cv.WaitKey(10) == 27:
break
def transmit_thread():
'''thread for image transmit to GCS'''
state = mpstate.camera_state
tx_count = 0
skip_count = 0
bsend = block_xmit.BlockSender(0, bandwidth=state.settings.bandwidth, debug=False)
state.bsocket = MavSocket(mpstate.mav_master[0])
state.bsend2 = block_xmit.BlockSender(mss=96, sock=state.bsocket, dest_ip='mavlink', dest_port=0, backlog=5, debug=False)
state.bsend2.set_bandwidth(state.settings.bandwidth2)
while not state.unload.wait(0.02):
bsend.tick(packet_count=1000, max_queue=state.settings.maxqueue1)
state.bsend2.tick(packet_count=1000, max_queue=state.settings.maxqueue2)
check_commands()
if state.transmit_queue.empty():
continue
(frame_time, regions, im_full, im_640) = state.transmit_queue.get()
if state.settings.roll_stabilised:
roll=0
else:
roll=None
pos = get_plane_position(frame_time, roll=roll)
# this adds the latlon field to the regions
log_joe_position(pos, frame_time, regions)
# filter out any regions outside the boundary
if state.boundary_polygon:
regions = cuav_region.filter_boundary(regions, state.boundary_polygon, pos)
regions = cuav_region.filter_regions(im_full, regions, min_score=state.settings.minscore)
state.xmit_queue = bsend.sendq_size()
state.xmit_queue2 = state.bsend2.sendq_size()
state.efficiency = bsend.get_efficiency()
state.bandwidth_used = bsend.get_bandwidth_used()
state.rtt_estimate = bsend.get_rtt_estimate()
jpeg = None
if len(regions) > 0:
lowscore = 0
highscore = 0
for r in regions:
lowscore = min(lowscore, r.score)
highscore = max(highscore, r.score)
if state.settings.transmit:
# send a region message with thumbnails to the ground station
thumb = None
if state.settings.send1:
thumb_img = cuav_mosaic.CompositeThumbnail(cv.GetImage(cv.fromarray(im_full)),
regions,
thumb_size=state.settings.thumbsize)
thumb = scanner.jpeg_compress(numpy.ascontiguousarray(cv.GetMat(thumb_img)), state.settings.quality)
pkt = ThumbPacket(frame_time, regions, thumb, state.frame_loss, state.xmit_queue, pos)
buf = cPickle.dumps(pkt, cPickle.HIGHEST_PROTOCOL)
bsend.set_bandwidth(state.settings.bandwidth)
bsend.set_packet_loss(state.settings.packet_loss)
bsend.send(buf,
dest=(state.settings.gcs_address, state.settings.gcs_view_port),
priority=1)
# also send thumbnails via 900MHz telemetry
if state.settings.send2 and highscore >= state.settings.minscore2:
if thumb is None or lowscore < state.settings.minscore2:
# remove some of the regions
regions = cuav_region.filter_regions(im_full, regions, min_score=state.settings.minscore2)
thumb_img = cuav_mosaic.CompositeThumbnail(cv.GetImage(cv.fromarray(im_full)),
regions,
thumb_size=state.settings.thumbsize)
thumb = scanner.jpeg_compress(numpy.ascontiguousarray(cv.GetMat(thumb_img)), state.settings.quality)
pkt = ThumbPacket(frame_time, regions, thumb, state.frame_loss, state.xmit_queue, pos)
buf = cPickle.dumps(pkt, cPickle.HIGHEST_PROTOCOL)
state.bsend2.set_bandwidth(state.settings.bandwidth2)
state.bsend2.send(buf, priority=highscore)
# Base how many images we send on the send queue size
send_frequency = state.xmit_queue // 3
if send_frequency == 0 or (tx_count+skip_count) % send_frequency == 0:
jpeg = scanner.jpeg_compress(im_640, state.settings.quality)
if jpeg is None:
skip_count += 1
continue
# keep filtered image size
state.jpeg_size = 0.95 * state.jpeg_size + 0.05 * len(jpeg)
tx_count += 1
if state.settings.gcs_address is None:
continue
bsend.set_packet_loss(state.settings.packet_loss)
bsend.set_bandwidth(state.settings.bandwidth)
pkt = ImagePacket(frame_time, jpeg, state.xmit_queue, pos)
str = cPickle.dumps(pkt, cPickle.HIGHEST_PROTOCOL)
bsend.send(str,
dest=(state.settings.gcs_address, state.settings.gcs_view_port))
grayIPimage = cv.GetImage(cv.fromarray(gray))
sobel = cv.CreateImage((w, h),cv2.IPL_DEPTH_16S, 1) #创建一张深度为16位有符号（-65536~65535）的的图像区域保持处理结果
cv.Sobel(grayIPimage,sobel,2,0,7) # 进行x方向的sobel检测
temp = cv.CreateImage(cv.GetSize(sobel),cv2.IPL_DEPTH_8U, 1) #图像格式转换回8位深度已进行下一步处理
cv.ConvertScale(sobel, temp,0.00390625, 0)
cv.Threshold(temp, temp, 0, 255, cv2.THRESH_OTSU)
kernal = cv.CreateStructuringElementEx(3,1, 1, 0, 0)
cv.Dilate(temp, temp,kernal,2)
cv.Erode(temp, temp,kernal,4)
cv.Dilate(temp, temp,kernal,2)
# cv.ShowImage('1', temp)
kernal = cv.CreateStructuringElementEx(1,3, 0, 1, 0)
cv.Erode(temp, temp,kernal,1)
cv.Dilate(temp, temp,kernal,3)
# cv.ShowImage('2', temp)
temp = np.asarray(cv.GetMat(temp))
contours, heirs = cv2.findContours(temp,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
for tours in contours:
rc = cv2.boundingRect(tours)
if rc[2]/rc[3] >= 2:
#rc[0] 表示图像左上角的纵坐标，rc[1] 表示图像左上角的横坐标，rc[2] 表示图像的宽度，rc[3] 表示图像的高度，
cv2.rectangle(image, (rc[0],rc[1]),(rc[0]+rc[2],rc[1]+rc[3]),(255,0,255))
imageIp = cv.GetImage(cv.fromarray(image))
cv.SetImageROI(imageIp, rc)
imageCopy = cv.CreateImage((rc[2], rc[3]),cv2.IPL_DEPTH_8U, 3)
cv.Copy(imageIp, imageCopy)
cv.ResetImageROI(imageIp)
cv.SaveImage('D:/pic/result/' + str(i) + '.jpg',imageCopy)
i = i +1
# cv2.imshow("黑底白字",image)
def run(self):
initialTime = 0. #sets the initial time
num_Frames = int(
cv.GetCaptureProperty(self.capture, cv.CV_CAP_PROP_FRAME_COUNT))
fps = cv.GetCaptureProperty(self.capture, cv.CV_CAP_PROP_FPS)
for ii in range(num_Frames - 8):
print('Frame: ' + str(ii) + ' of ' + str(num_Frames))
# read the ii-th frame
img = cv.QueryFrame(self.capture)
# Blur the source image to reduce color noise
cv.Smooth(img, img, cv.CV_BLUR, 3)
# Convert the image to hsv(Hue, Saturation, Value) so its
# It's easier to determine the color to track(hue)
hsv_img = cv.CreateImage(cv.GetSize(img), 8, 3)
cv.CvtColor(img, hsv_img, cv.CV_BGR2HSV)
# limit all pixels that don't match our criteria, in the is case we are
# looking for purple but if you want you can adjust the first value in
# both turples which is the hue range(120,140). OpenCV uses 0-180 as
# a hue range for the HSV color model
thresholded_img = cv.CreateImage(cv.GetSize(hsv_img), 8, 1)
# uncomment below for tracking blue
# cv.InRangeS(hsv_img, (112, 50, 50), (118, 200, 200), thresholded_img)
# tracking red
cv.InRangeS(hsv_img, (160, 150, 100), (180, 255, 255),
thresholded_img)
#determine the objects moments and check that the area is large
#enough to be our object
thresholded_img2 = cv.GetMat(thresholded_img)
moments = cv.Moments(thresholded_img2, 0)
area = cv.GetCentralMoment(moments, 0, 0)
# there can be noise in the video so ignore objects with small areas
if (area > 2500):
#determine the x and y coordinates of the center of the object
#we are tracking by dividing the 1, 0 and 0, 1 moments by the area
x = cv.GetSpatialMoment(moments, 1, 0) / area
y = cv.GetSpatialMoment(moments, 0, 1) / area
elapsedTime = ii / fps
f.write(
str(elapsedTime) + ',' + '%013.9f' % x + ',' +
'%013.9f' % y + "\n"
) #prints output to the specified output file for later use
#
# x = int(x)
# y = int(y)
#
# #create an overlay to mark the center of the tracked object
# overlay = cv.CreateImage(cv.GetSize(img), 8, 3)
#
# cv.Circle(overlay, (x, y), 2, (255, 255, 255), 20)
# cv.Add(img, overlay, img)
# #add the thresholded image back to the img so we can see what was
# #left after it was applied
# cv.Merge(thresholded_img, None, None, None, img)
#
# #display the image
# cv.ShowImage(color_tracker_window, img)
# close the data file
f.close()
if frame is None:
break
# mirror
cv.Flip(frame, None, 1)
originalImage = frame
hsvImage = cv.CreateImage(cv.GetSize(originalImage), 8, 3)
cv.CvtColor(originalImage, hsvImage, cv.CV_BGR2HSV)
thresholdImage = cv.CreateImage(cv.GetSize(originalImage), 8, 1)
cv.InRangeS(hsvImage, cv.Scalar(20.74, 75, 75),
cv.Scalar(30.74, 255, 255), thresholdImage)
thresholdImageArray = np.asarray(cv.GetMat(thresholdImage))
thresholdImageArray = cv2.GaussianBlur(thresholdImageArray, (0, 0), 2)
thresholdImage = cv.fromarray(thresholdImageArray)
circles = cv2.HoughCircles(thresholdImageArray,
cv.CV_HOUGH_GRADIENT,
2,
10,
param1=40,
param2=80,
minRadius=4,
maxRadius=1500)
if circles is not None:
if circles.size > 0:
cv.NamedWindow("video")
cv.NamedWindow("thresh")
tmp = cv.QueryFrame(capture)
imgScribble = cv.CreateImage(cv.GetSize(tmp), 8,
3) #Image that will contain lines
posx = 0
posy = 0
while True:
frame = cv.QueryFrame(capture)
imgYellowTresh = getThresholdImage(frame) #Apply the threshold function
moments = cv.Moments(cv.GetMat(imgYellowTresh), 1)
moment10 = cv.GetSpatialMoment(moments, 1, 0)
moment01 = cv.GetSpatialMoment(moments, 0, 1)
area = cv.GetCentralMoment(moments, 0, 0) #Get the center
lastx = posx
lasty = posy
if area == 0:
posx = 0
posy = 0
else:
posx = moment10 / area
posy = moment01 / area
if lastx > 0 and lasty > 0 and posx > 0 and posy > 0: #Mean we have received coordinates to print
#Draw the line
import cv2.cv as cv
import numpy
if __name__ == "__main__":
cv.NamedWindow("camera", 1)
capture = cv.CaptureFromCAM(0)
paste = cv.CreateMat(960, 1280, cv.CV_8UC3)
topleft = numpy.asarray(cv.GetSubRect(paste, (0, 0, 640, 480)))
topright = numpy.asarray(cv.GetSubRect(paste, (640, 0, 640, 480)))
bottomleft = numpy.asarray(cv.GetSubRect(paste, (0, 480, 640, 480)))
bottomright = numpy.asarray(cv.GetSubRect(paste, (640, 480, 640, 480)))
while True:
img = cv.GetMat(cv.QueryFrame(capture))
n = (numpy.asarray(img)).astype(numpy.uint8)
red = n[:,:,2]
grn = n[:,:,1]
blu = n[:,:,0]
topleft[:,:,0] = blu
topleft[:,:,1] = grn
topleft[:,:,2] = red
color = red
topright[:,:,0] = blu - red
topright[:,:,1] = grn
