def TrackFile(anim): tracks = cvb.Tracks() capture = cv.CreateFileCapture(anim) cv.GrabFrame(capture) img = cv.RetrieveFrame(capture) frame = cv.CreateImage(cv.GetSize(img), img.depth, img.nChannels) cnt = 1 while cv.GrabFrame(capture): # Capture Frames img = cv.RetrieveFrame(capture) cv.ResetImageROI(frame) cv.ConvertScale(img, frame, 1, 0) cv.Threshold(frame, frame, 100, 200, cv.CV_THRESH_BINARY) #rct=cv.Rectangle(0, 25, 383, 287) cv.SetImageROI(frame, (0, 25, 383, 287)) chB = cv.CreateImage(cv.GetSize(frame), 8, 1) cv.Split(frame, chB, None, None, None) labelImg = cv.CreateImage(cv.GetSize(frame), cvb.IPL_DEPTH_LABEL, 1) # Get Blobs and try Update Tracks blobs = cvb.Blobs() result = cvb.Label(chB, labelImg, blobs) cvb.FilterByArea(blobs, 500, 1000) # Trys are implemented here just to ensure crashes don't happen when blobs are not present try: print type(blobs.items()[0][1]) except: pass cvb.UpdateTracks(blobs, tracks, 5., 10, 0) try: print type(blobs.items()[0][1]) except: pass try: print type(tracks.items()[0][1]) except: pass imgOut = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 3) cv.Zero(imgOut) cvb.RenderBlobs( labelImg, blobs, frame, imgOut, cvb.CV_BLOB_RENDER_COLOR | cvb.CV_BLOB_RENDER_CENTROID | cvb.CV_BLOB_RENDER_BOUNDING_BOX) # Save images to see what's blobs are getting out. cnt = cnt + 1 print cnt # cv.SaveImage('blobs' + str(cnt) + '.png', imgOut) return tracks, blobs
def get_image(self): """ Retrieve an image of the correct type from the Kinect, depending on the type that was passed to the constructor. Since the classes share a OpenNI camera instance, only obtain the image at the set update frequency. """ global NI_grabtime global NI_camera if time.time() > NI_grabtime + self.grab_interval: cv.GrabFrame(NI_camera) NI_grabtime = time.time() if self.img_type == "depth": depth = cv.RetrieveFrame(NI_camera, cv.CV_CAP_OPENNI_DEPTH_MAP) temp = cv.CreateImage(cv.GetSize(depth), cv.IPL_DEPTH_8U, 1) cv.ConvertScale(depth, temp, 0.0625, 0.0) # temp = doUsefulConvert8(cv2array(depth)) elif self.img_type == "rgb": temp = cv.RetrieveFrame(NI_camera, cv.CV_CAP_OPENNI_BGR_IMAGE) elif self.img_type == "pcl": temp = cv.RetrieveFrame(NI_camera, cv.CV_CAP_OPENNI_POINT_CLOUD_MAP) if temp == None: raise Exception("Unable to start Kinect, check connection") return temp
def run(self): global _camera, lock while self.running: lock.acquire() try: cv.GrabFrame(cam) finally: lock.release()
def ar_video_for_ui(self): cap = cv.CaptureFromCAM(0) if not cap: sys.stdout.write("failed CaptureFromCAM") while True: if not cv.GrabFrame(cap): break frame = cv.RetrieveFrame(cap) sys.stdout.write(frame.tostring())
def main(): tree = utils.open_project(sys.argv) if tree == None: return try: os.mkdir(OUTPUT_DIR) except OSError: pass movie = tree.getroot() file_path = movie.attrib["path"] #fps = float( movie.attrib["fps"] ) cap = cv.CreateFileCapture(file_path) cv.QueryFrame(cap) # skip frames in the beginning, if neccessary start_frame = int(movie.attrib["start_frame"]) for i in range(start_frame): cv.QueryFrame(cap) end_frame = int(movie.attrib["end_frame"]) every_nth_frame = int((end_frame - start_frame) / 100) print "every", every_nth_frame, "frames" #print "=", every_nth_frame / fps, "sec" frame = start_frame counter = 1 while 1: print counter img = cv.QueryFrame(cap) if not img or frame > end_frame: break img_small = cv.CreateImage( (WIDTH, int(img.height * float(WIDTH) / img.width)), cv.IPL_DEPTH_8U, 3) cv.Resize(img, img_small, cv.CV_INTER_CUBIC) cv.SaveImage(os.path.join(OUTPUT_DIR, "still_%07d.jpg" % (frame)), img_small) for i in range(every_nth_frame - 1): cv.GrabFrame(cap) frame += every_nth_frame counter += 1 #raw_input("- done -") return
def dequeue(self): # flush cv.GrabFrame(self.cam) im = cv.RetrieveFrame(self.cam) #cv.Flip(im, None, 1) img = cv.CreateImage(cv.GetSize(im), 8, 1) cv.CvtColor(im, img, cv.CV_BGR2GRAY) im = img a = np.fromstring(im.tostring(), dtype=self.depth2dtype[im.depth], count=im.width*im.height*im.nChannels) a.shape = (im.height, im.width, im.nChannels) return a[:, :, 0]
def run(self): global _camera, lock while self.running: """ I'm using a lock to use the resource uninterrupted. Currently variable, where camera image is saved, can be called in two threads, which can make one of them crash. Lock is the simplest way of avoiding crashing when using a shared resource """ lock.acquire() try: cv.GrabFrame(_camera) print "Frame grabbed" finally: lock.release()
def camera_capture(): # /dev/video0 c = cv.CaptureFromCAM(0) #assert type(c) == "cv.Capture" # or use QueryFrame. It's the same cv.GrabFrame(c) image = cv.RetrieveFrame(c) #image = cv.QueryFrame(c) assert image != None dst = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 3) #im = cv.CloneImage(image) laplace = cv.Laplace(image, dst) cv.SaveImage("my-camera.png", dst) print cv.GetCaptureProperty(c, cv.CV_CAP_PROP_FRAME_HEIGHT)
def load_video_clip(video_file, start_frame=0, end_frame=None, verbose=False): """Loads frames from a video_clip Args: video_file: path of the video file start_frame: first frame to be loaded end_frame: last frame to be loaded Returns: A (#frames)x(height)x(width)x(#channels) NumPy array containing the video clip """ if not os.path.exists(video_file): raise IOError, 'File "%s" does not exist!' % video_file capture = cv.CaptureFromFile(video_file) if not end_frame: end_frame = int( cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_COUNT)) else: end_frame = int( min(end_frame, cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_COUNT))) width = cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH) height = cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT) if verbose: print "end_frame: %d" % end_frame print "clip has %d frames" % int( cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_COUNT)) for _ in range(start_frame): # frames start with 1 in annotation files cv.GrabFrame(capture) frames = np.zeros((end_frame - start_frame - 2, height, width), dtype=np.uint8) for i in range(end_frame - start_frame - 2): # end_frame = last action frame img = cv.QueryFrame(capture) if img is None: continue tmp = cv.CreateImage(cv.GetSize(img), 8, 1) cv.CvtColor(img, tmp, cv.CV_BGR2GRAY) frames[i, :] = np.asarray(cv.GetMat(tmp)) return np.array(frames)
#!/usr/bin/python import cv video = cv.CaptureFromFile( "rtsp://admin:@192.168.0.19/user=admin&password=&channel=1&stream=0.sdp?") cv.NamedWindow("IP Camera", cv.CV_WINDOW_AUTOSIZE) #contador = 1 while True: # img = cv.QueryFrame(video) # cv.SaveImage("/var/www/html/teste.jpg",img) cv.GrabFrame(video) frame = cv.RetrieveFrame(video) cv.ShowImage("IP Camera", frame) cv.WaitKey(150) # print contador # contador = contador + 1
#speed = [1, 1] #black = 0, 0, 0 #print os.path.isfile('/dev/video0') #print os.path.exists('/dev/video0') if os.path.exists('/dev/video0') ==False: print "no video0,exit" sys.exit(2) try: cam = cv.CreateCameraCapture(0) cv.SetCaptureProperty(cam,cv.CV_CAP_PROP_FRAME_WIDTH, 640) cv.SetCaptureProperty(cam,cv.CV_CAP_PROP_FRAME_HEIGHT, 480); except: print "system error,exit" sys.exit(1) k=0 t = time.strftime('%Y%m%d%H%M%S',time.localtime(time.time())) filename = '%s.jpg' %(t) while 1: k += 1 if k > 8: break try: cv.GrabFrame(cam) img = cv.RetrieveFrame(cam) cv.SaveImage(filename, img) except: pass cv.WaitKey(1500)
def main(): cv.NamedWindow('frame', cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow('frame', 10, 10) cv.NamedWindow('edges', cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow('edges', 600, 10) parser = OptionParser() parser.add_option('-s', '--seek', action='store', type='int', dest='seek', default=0) parser.add_option('-i', '--image', action='store_true', dest='image', default=False) parser.add_option('-v', '--verbose', action='store_true', dest='verbose', default=False) options, args = parser.parse_args() global verbose verbose = options.verbose if options.image: # Use image frame = cv.LoadImage(args[0]) if frame is None: print 'Error loading image %s' % args[0] return find_lines(frame) # Pause for key press while True: k = cv.WaitKey(33) if k == ord('q'): break else: if len(args) > 0: # Use video cam = cv.CaptureFromFile(args[0]) if cam is None: print 'Error opening file' return else: # Use webcam cam = cv.CreateCameraCapture(1) if cam is None: print 'Error opening camera' return # Seek to initial position by discarding frames for i in range(options.seek): cv.GrabFrame(cam) while True: frame = cv.QueryFrame(cam) if frame is None: print 'End of video' break find_lines(frame) k = cv.WaitKey(10) if k == ord('q'): break cv.ReleaseCapture(cam)
def getCoordinates(self, target="ball", debug=False): t = time.time() """ This function will return the best coordinates found by thresholding the received image by the chosen threshold. """ """Get the latest frame from the camera""" global cam, lock lock.acquire() try: cv.GrabFrame(cam) frame = cv.RetrieveFrame(cam) finally: lock.release() """Initialize the coordinates to -1, which means that the object is not found""" x = -1 y = -1 """Prepair image for thresholding""" #cv.Smooth(thresholded_frame, thresholded_frame, cv.CV_GAUSSIAN, 5, 5) cv.Smooth(frame, frame, cv.CV_BLUR, 3) cv.CvtColor(frame, self.hsv_frame, cv.CV_BGR2HSV) """Threshold the image according to the chosen thresholds""" if target == "ball": cv.InRangeS(self.hsv_frame, self.ball_threshold_low, self.ball_threshold_high, self.thresholded_frame) elif target == "blue gate": cv.InRangeS(self.hsv_frame, self.blue_gate_threshold_low, self.blue_gate_threshold_high, self.thresholded_frame) elif target == "yellow gate": cv.InRangeS(self.hsv_frame, self.yellow_gate_threshold_low, self.yellow_gate_threshold_high, self.thresholded_frame) elif target == "black": cv.InRangeS(self.hsv_frame, self.black_threshold_low, self.black_threshold_high, self.thresholded_frame) elif target == "white": cv.InRangeS(self.hsv_frame, self.white_threshold_low, self.white_threshold_high, self.thresholded_frame) cv.InRangeS(self.hsv_frame, self.green_threshold_low, self.green_threshold_high, self.thresholded_field) """Now use some function to find the object""" blobs_image = SimpleCV.Image(self.thresholded_frame) field_image = SimpleCV.Image(self.thresholded_field) blobs = blobs_image.findBlobs(minsize=2) if blobs: if target == "ball": for i in range(len(blobs)): i = len(blobs) - 1 - i pos_x = blobs[i].maxX() pos_y = blobs[i].maxY() on_field = False for py in range(0, pos_y): if field_image.getPixel(pos_x, py) == (255, 255, 255): on_field = True break if on_field: x, y = pos_x, pos_y break else: x, y = blobs[-1].coordinates() """Old, openCV using contours contours = cv.FindContours(cv.CloneImage(thresholded_frame), cv.CreateMemStorage(),mode=cv.CV_RETR_EXTERNAL) if len(contours)!=0: #determine the objects moments and check that the area is large #enough to be our object moments = cv.Moments(contours,1) moment10 = cv.GetSpatialMoment(moments, 1, 0) moment01 = cv.GetSpatialMoment(moments, 0, 1) area = cv.GetCentralMoment(moments, 0, 0) #there can be noise in the video so ignore objects with small areas if area > 2: #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 = moment10/area y = moment01/area""" if debug: cv.ShowImage("Camera", self.thresholded_frame) #thresholded_frame=SimpleCV.Image(thresholded_frame) #thresholded_frame.show() print time.time() - t return x, y
def grab(self): return cv.GrabFrame(self.cv_capture)
corner = clusters[0][0] else: fg = averages[clusters[1][0]] bg = averages[clusters[0][0]] corner = clusters[1][0] if (fg > bg): return (corner, "w") else: return (corner, "b") #solve_camera(xyz,xy) print sys.argv[1] capture = cv.CaptureFromFile(sys.argv[1]) cv.GrabFrame(capture) img = cv.RetrieveFrame(capture) img2 = cv.CloneImage(img) eig_image = cv.CreateMat(img.height, img.width, cv.CV_32FC1) temp_image = cv.CreateMat(img.height, img.width, cv.CV_32FC1) img32f = cv.CreateImage((img.width, img.height), cv.IPL_DEPTH_32F, 3) cv.Convert(img, img32f) img_gs = cv.CreateImage((img.width, img.height), cv.IPL_DEPTH_32F, 1) cv.CvtColor(img32f, img_gs, cv.CV_RGB2GRAY) font = cv.InitFont(cv.CV_FONT_HERSHEY_PLAIN, 1.0, 1.0) def tand(alpha): return tan(alpha * 3.1415926 / 180)
def grab(self): """Grab a frame from capture device""" return cv.GrabFrame(self.capture)
def getCoordinates(self, target="ball", debug=False): """ This function will return the best coordinates found by thresholding the received image by the chosen threshold. """ """Get the latest frame from the camera""" global cam, lock lock.acquire() try: cv.GrabFrame(cam) frame = cv.RetrieveFrame(cam) finally: lock.release() """Initialize the coordinates to -1, which means that the object is not found""" x = -1 y = -1 """Prepair image for thresholding""" #cv.Smooth(thresholded_frame, thresholded_frame, cv.CV_GAUSSIAN, 5, 5) cv.Smooth(frame, frame, cv.CV_BLUR, 3) cv.CvtColor(frame, self.hsv_frame, cv.CV_BGR2HSV) """Threshold the image according to the chosen thresholds""" if target == "ball": cv.InRangeS(self.hsv_frame, self.ball_threshold_low, self.ball_threshold_high, self.thresholded_frame) elif target == "blue gate": cv.InRangeS(self.hsv_frame, self.blue_gate_threshold_low, self.blue_gate_threshold_high, self.thresholded_frame) elif target == "yellow gate": cv.InRangeS(self.hsv_frame, self.yellow_gate_threshold_low, self.yellow_gate_threshold_high, self.thresholded_frame) elif target == "black": cv.InRangeS(self.hsv_frame, self.black_threshold_low, self.black_threshold_high, self.thresholded_frame) elif target == "white": cv.InRangeS(self.hsv_frame, self.white_threshold_low, self.white_threshold_high, self.thresholded_frame) else: #green cv.InRangeS(self.hsv_frame, self.green_threshold_low, self.green_threshold_high, self.thresholded_frame) """Now use some function to find the object""" blobs_image = SimpleCV.Image(self.thresholded_frame) blobs = blobs_image.findBlobs() if blobs: for i in range(len(blobs)): line = blobs[i] angle = line.angle() pos_x, pos_y = line.coordinates() if line.maxY() > 100: y = line.maxY() if angle > 0: x = line.maxX() else: x = line.minX() break if debug: cv.ShowImage("Camera", self.thresholded_frame) #thresholded_frame=SimpleCV.Image(thresholded_frame) #blobs_image.show() return x, y
'''capture.py''' import cv, sys cap = cv.CaptureFromCAM(0) # 0 is for /dev/video0 while True: if not cv.GrabFrame(cap): break frame = cv.RetrieveFrame(cap) sys.stdout.write(frame.tostring())
if not img: break <<<<<<< HEAD:02_5_100-stills.py img_small = cv.CreateImage((WIDTH, int( img.height * float(WIDTH)/img.width )), cv.IPL_DEPTH_8U, 3) cv.Resize(img, img_small, cv.CV_INTER_CUBIC) cv.SaveImage(os.path.join(OUTPUT_DIR,"still_%07d.jpg" % (frame)), img_small) ======= cv.SaveImage(OUTPUT_DIR + "\\still_%07d.jpg" % (frame), img) >>>>>>> parent of 1f8384f... minor changes:stills_100.py for i in range(every_nth_frame-1): cv.GrabFrame(cap) frame += every_nth_frame <<<<<<< HEAD:02_5_100-stills.py #raw_input("- done -") ======= counter += 1 raw_input("- done -") >>>>>>> parent of 1f8384f... minor changes:stills_100.py return # ######################### if __name__ == "__main__":
def GetRawDartXY(): global capture global image if calibration.debug: # the coordinates global x_coordinate global y_coordinate x_coordinate = 0 y_coordinate = 0 #use this events wait for mouse click global mouse_click_down mouse_click_down = Event() cv.NamedWindow(window_name, 1) cv.SetMouseCallback(window_name, on_mouse) while not mouse_click_down.is_set(): if calibration.from_video: cv.GrabFrame(capture) image = cv.RetrieveFrame(capture) cv.ShowImage(window_name, image) cv.WaitKey(1) mouse_click_down.clear() ## clone = cv.CloneImage(image) ## ## cv.Circle(clone,(x_coordinate,y_coordinate),3,cv.CV_RGB(255, 0, 0),2) ## cv.ShowImage(window_name, clone) return (x_coordinate, y_coordinate) else: motion = 0 ## capture = 0 darts_found = list() detected_x = 0 detected_y = 0 no_dart_prev = True no_dart_prev_prev = True ## draw = False ## parser = OptionParser(usage = "usage: %prog [options]") ## parser.add_option("-c", "--cascade", action="store", dest="cascade", type="str", help="Haar cascade file, default %default", default = "default.xml") ## parser.add_option("-f", "--videofile", action="store", dest="videofile", type="str", help="Video capture file, default is to capture from camera", default = None) ## ## (options, args) = parser.parse_args() ## ## cascade = cv.Load(options.cascade) ## videofile = options.videofile ## ## if videofile == None: ## capture = cv.CreateCameraCapture(0) ## else: ## capture = cv.CaptureFromFile(videofile) cascade = cv.Load(calibration.cascadefile) ## cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH, 640) ## cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT , 480) cv.NamedWindow("Motion") cv.NamedWindow('Original') while True: image = cv.QueryFrame(capture) ## cv.GrabFrame(capture) ## image = cv.RetrieveFrame(capture) image_clone = cv.CloneImage(image) if (image): if (not motion): motion = cv.CreateImage((image.width, image.height), 8, 1) cv.Zero(motion) update_mhi(image, motion, 30) # no darts 2 frames ago no_dart_prev_prev = no_dart_prev # no darts 1 frame ago no_dart_prev = (len(darts_found) == 0) # when we transition from having a dart frame to not having a # dart frame, then the dart coordinates are stable and we can return if (no_dart_prev_prev == False) and (no_dart_prev == True): # we can return here ## draw = True ## print 'Dart detected at ({0},{1})'.format(detected_x,detected_y) ## cv.Circle(image_clone,(detected_x,detected_y),3,cv.RGB(255,0,0),3) ## cv.ShowImage('Original',image_clone) ## print 'at',cv.GetCaptureProperty(capture,cv.CV_CAP_PROP_POS_FRAMES) return (detected_x, detected_y) darts_found = [] detect(motion, cascade, darts_found) # if the number of pixels that changed is outside of the accepted # bound, then we say this is not a dart throw # the bounds are determined experimentally if not (pixels_lo_bound < cv.CountNonZero(motion) < pixels_hi_bound): darts_found = [] for dart_rec in darts_found: ## draw = False x_dart = dart_rec[0] y_dart = dart_rec[1] width_dart = dart_rec[2] height_dart = dart_rec[3] cv.Rectangle(image_clone, (x_dart, y_dart), (x_dart + width_dart, y_dart + height_dart), cv.RGB(0, 0, 255), 3, 8, 0) done = False for x in range(x_dart, x_dart + width_dart, 1): if done: break for y in range(y_dart + height_dart, y_dart, -1): # Get2D looks at a matrix, so we have access the # Yth row and the Xth column!!! if cv.Get2D(motion, y, x) != cv.Scalar(0): if non_zero_in_conv_table( motion, x, y) > dart_tip_threshold: if no_dart_prev: detected_x = x detected_y = y else: if x < detected_x: detected_x = x detected_y = y done = True break ## if draw: ## cv.Circle(image,(detected_x,detected_y),3,cv.RGB(255,0,0),3) ## cv.ShowImage('Original', image_clone) cv.ShowImage("Motion", motion) key = cv.WaitKey(1) if (key == 27): break else: break raise Exception('GetDart() failed unexpectedly')
def main(): if len(sys.argv) == 1: print 'Usage: %s [inputfile]' % sys.argv[0] sys.exit(1) # initialize window cv.NamedWindow('video', cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow('video', 10, 10) cv.NamedWindow('threshold', cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow('threshold', 10, 500) cv.NamedWindow('flow', cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow('flow', 500, 10) cv.NamedWindow('edges', cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow('edges', 500, 500) cv.NamedWindow('combined', cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow('combined', 1000, 10) capture = cv.CreateFileCapture(sys.argv[1]) if not capture: print 'Error opening capture' sys.exit(1) # Load bg image bg = cv.LoadImage('bg.png') # Discard some frames for i in xrange(2300): cv.GrabFrame(capture) frame = cv.QueryFrame(capture) frame_size = cv.GetSize(frame) # vars for playback fps = 25 play = True velx = cv.CreateImage(frame_size, cv.IPL_DEPTH_32F, 1) vely = cv.CreateImage(frame_size, cv.IPL_DEPTH_32F, 1) combined = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 1) prev = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 1) curr = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 1) frame_sub = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 3) edges = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 1) prev_edges = None storage = cv.CreateMemStorage(0) blob_mask = cv0.cvCreateImage(frame_size, cv.IPL_DEPTH_8U, 1) cv0.cvSet(blob_mask, 1) hough_in = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 1) hough_storage = cv.CreateMat(100, 1, cv.CV_32FC3) ''' cv.CvtColor(frame, prev, cv.CV_BGR2GRAY) frame = cv.QueryFrame(capture) cv.CvtColor(frame, curr, cv.CV_BGR2GRAY) # winSize can't have even numbers cv.CalcOpticalFlowLK(prev, curr, (3,3), velx, vely) cv.ShowImage('video', frame) cv.ShowImage('flow', velx) cv.WaitKey(0) ''' while True: if play: frame = cv.QueryFrame(capture) cv.Sub(frame, bg, frame_sub) '''#detect people found = list(cv.HOGDetectMultiScale(frame, storage, win_stride=(8,8), padding=(32,32), scale=1.05, group_threshold=2)) for r in found: (rx, ry), (rw, rh) = r tl = (rx + int(rw*0.1), ry + int(rh*0.07)) br = (rx + int(rw*0.9), ry + int(rh*0.87)) cv.Rectangle(frame, tl, br, (0, 255, 0), 3) ''' #color thresholding hsv = cv.CreateImage(frame_size, cv.IPL_DEPTH_8U, 3) cv.CvtColor(frame, hsv, cv.CV_BGR2HSV) mask = cv.CreateMat(frame_size[1], frame_size[0], cv.CV_8UC1) cv.InRangeS(hsv, (0.06 * 256, 0.2 * 256, 0.6 * 256, 0), (0.16 * 256, 1.0 * 256, 1.0 * 256, 0), mask) cv.ShowImage('threshold', mask) #optical flow method # store previous frame prev, curr = curr, prev # convert next frame to single channel grayscale cv.CvtColor(frame_sub, curr, cv.CV_BGR2GRAY) #cv.CalcOpticalFlowLK(prev, curr, (3,3), velx, vely) #cv.Threshold(velx, velx, 8.0, 0, cv.CV_THRESH_TOZERO) cv.CalcOpticalFlowHS(prev, curr, 1, velx, vely, 0.5, (cv.CV_TERMCRIT_ITER, 10, 0)) cv.Threshold(velx, velx, 0.5, 0, cv.CV_THRESH_TOZERO) cv.Threshold(vely, vely, 0.5, 0, cv.CV_THRESH_TOZERO) cv.Erode( vely, vely, cv.CreateStructuringElementEx(2, 2, 0, 0, cv.CV_SHAPE_ELLIPSE)) cv.Add(vely, velx, vely) cv.ShowImage('flow', vely) #edge detection cv.Canny(curr, edges, 50, 100) cv.Dilate( edges, edges, cv.CreateStructuringElementEx(7, 7, 0, 0, cv.CV_SHAPE_ELLIPSE)) cv.ShowImage('edges', edges) if prev_edges: cv.CalcOpticalFlowHS(prev_edges, edges, 1, velx, vely, 0.5, (cv.CV_TERMCRIT_ITER, 10, 0)) cv.Threshold(velx, velx, 0.5, 0, cv.CV_THRESH_TOZERO) cv.Threshold(vely, vely, 0.5, 0, cv.CV_THRESH_TOZERO) cv.ShowImage('flow', vely) prev_edges = edges cv.Threshold(vely, combined, 0.5, 255, cv.CV_THRESH_BINARY) cv.Min(combined, edges, combined) cv.ShowImage('combined', combined) # blobs myblobs = CBlobResult(edges, blob_mask, 100, False) myblobs.filter_blobs(10, 10000) blob_count = myblobs.GetNumBlobs() for i in range(blob_count): my_enumerated_blob = myblobs.GetBlob(i) # print "%d: Area = %d" % (i, my_enumerated_blob.Area()) my_enumerated_blob.FillBlob(frame, hsv2rgb(i * 180.0 / blob_count), 0, 0) cv.ShowImage('video', frame) ''' crashes #hough transform on dilated image #http://wiki.elphel.com/index.php? # title=OpenCV_Tennis_balls_recognizing_tutorial&redirect=no cv.Copy(edges, hough_in) cv.Smooth(hough_in, hough_in, cv.CV_GAUSSIAN, 15, 15, 0, 0) cv.HoughCircles(hough_in, hough_storage, cv.CV_HOUGH_GRADIENT, 4, frame_size[1]/10, 100, 40, 0, 0) print hough_storage ''' k = cv.WaitKey(1000 / fps) if k == 27: # ESC key break elif k == 'p': # play/pause play = not play