def displayRedOrBlue(dev, data, timestamp): global keep_running global red global iter if(red): lower = np.array(boundaries[0], dtype = "uint8") upper = np.array(boundaries[1], dtype = "uint8") iter+=1 elif(not red): lower = np.array(boundaries[2], dtype = "uint8") upper = np.array(boundaries[3], dtype = "uint8") iter+=1 if(iter%10==0): red = not red mask = cv2.inRange(frame_convert2.video_cv(data), lower, upper) output = cv2.bitwise_and(frame_convert2.video_cv(data), frame_convert2.video_cv(data), mask = mask) gray = cv2.cvtColor(output, cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, (7, 7), 0) # perform edge detection, then perform a dilation + erosion to # close gaps in between object edges edged = cv2.Canny(gray, 50, 100) edged = cv2.dilate(edged, None, iterations=1) edged = cv2.erode(edged, None, iterations=1) # find contours in the edge map cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) cv2.imshow('Red and Blue', output) if cv2.waitKey(10) == 27: keep_running = False
def display_rgb(dev, data, timestamp): global keep_running print frame_convert2.video_cv(data) c = cv2.waitKey(10) if 'q' == chr(c & 255): keep_running = False if 's' == chr(c & 255): cv2.imwrite("saved1.jpg", frame_convert2.video_cv(data))
def display_blue(dev, data, timestamp): global keep_running lower = np.array(boundaries[2], dtype = "uint8") upper = np.array(boundaries[3], dtype = "uint8") # find the colors within the specified boundaries and apply # the mask mask = cv2.inRange(frame_convert2.video_cv(data), lower, upper) output = cv2.bitwise_and(frame_convert2.video_cv(data), frame_convert2.video_cv(data), mask = mask) cv2.imshow('Blue', output) if cv2.waitKey(10) == 27: keep_running = False
def draw_canny(data): gray = frame_convert2.video_cv(data) gray = cv2.cvtColor(data, cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, (5, 5), 0) edged = cv2.Canny(gray, 35, 125) return edged
def collect_rgb(dev, data, timestamp): global keep_running global rgb_index np.save('{0}/{1}/{2}'.format(ROOT_PATH, RGB_PATH, rgb_index), data) rgb_index += 1 cv2.imshow('RGB', frame_convert2.video_cv(data)) if cv2.waitKey(10) == 27: keep_running = False
def get_video(): global cam data = frame_convert2.video_cv(freenect.sync_get_video()[0]) #data,_ = freenect.sync_get_video() #data = cv2.cvtColor(data, cv2.COLOR_RGB2BGR) img = cv2.imencode('.JPEG', data)[1].tostring() enData = base64.b64encode(img).decode('UTF-8') return enData
def display_rgb(dev, data, timestamp): global keep_running global faceCascade global light global tilt global search global faces global ser global last_time camera_x_center = 320 image = frame_convert2.video_cv(data) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Detect faces in the image faces = faceCascade.detectMultiScale( gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30), flags = cv2.CASCADE_SCALE_IMAGE ) print "found {0} face(s)".format(len(faces)) if len(faces) > 0: search = False light = 1 face_x_center = faces[0][0] + faces[0][2]/2 face_y_center = faces[0][1] + faces[0][3]/2 diff = face_x_center - camera_x_center # print diff if diff > 32: print "face on the right side, turn right!" elif diff < -32: print "face on the left side, turn left!" else : print "face straight ahead" else: print "no face" diff = 640 search = True light = 3 print diff ser.write(str(diff-641)) c = cv2.waitKey(10) if 'q' == chr(c & 255): keep_running = False if 's' == chr(c & 255): cv2.imwrite('detected.jpg', image) image = cv2.imread('detected.jpg') for (x, y, w, h) in faces: cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2) cv2.imwrite('detected.jpg', image)
def display_rgb(dev, data, timestamp): # pass global keep_running im = frame_convert2.video_cv(data) # im = im_or.copy() # pdb.set_trace() if len(im) is not 0: cls,det = CNN.detect(net,im) # print(det[0,0:4]) print det.shape
def display_camera_half(self, dev, data, timestamp): faces = self.facial_recog(data) for (x, y, w, h) in faces: cv2.rectangle(data, (x, y), (x + w, y + h), (0, 255, 0), 2) data = cv2.resize(data, (1280, 720)) cv2.imshow('RGB', frame_convert2.video_cv(data)) if cv2.waitKey(1) == 27: self.keep_running = [False]
def display_rgb(dev, data, timestamp): global keep_running global tilt global light cv2.imshow('RGB', frame_convert2.video_cv(data)) c = cv2.waitKey(10) if 'q' == chr(c & 255): keep_running = False if 's' == chr(c & 255): cv2.imwrite("saved.jpg", frame_convert2.video_cv(data)) if 'u' == chr(c & 255): tilt = 25 if 'd' == chr(c & 255): tilt = 5 if '1' == chr(c & 255): light = 1 if '2' == chr(c & 255): light = 2 if '3' == chr(c & 255): light = 3
def display_camera_full(self, dev, data, timestamp): data = cv2.resize(data, (1900, 1050)) faces = self.facial_recog(data) for (x, y, w, h) in faces: cv2.rectangle(data, (x, y), (x + w, y + h), (0, 255, 0), 2) rgb = data[:, :, ::-1] self.recognizer.recognize(rgb) cv2.imshow('RGB', frame_convert2.video_cv(data)) if cv2.waitKey(1) == 27: self.keep_running = [False]
def display_rgb(delay): i = 0 while 1: try: data = np.load('{0}/{1}/{2}.npy'.format(ROOT_PATH, RGB_PATH, i)) cv2.imshow('RGB', frame_convert2.video_cv(data)) if cv2.waitKey(delay) == 27: break except Exception: break if DEBUG: print i i += 1
def display_camera_fourth(self, dev, data, timestamp): faces = self.facial_recog(data) for (x, y, w, h) in faces: cv2.rectangle(data, (x, y), (x + w, y + h), (0, 255, 0), 2) print('faces') #print(faces) rgb = data[:, :, ::-1] locations = [[y, x + w, y + h, x] for (x, y, w, h) in faces] print(locations) if len(locations) > 0: print(self.recognizer.recognize_face_loc(rgb, locations)) cv2.imshow('RGB', frame_convert2.video_cv(data)) if cv2.waitKey(1) == 27: self.keep_running = [False]
def display_rgb(dev, data, timestamp): t_start = datetime.datetime.now() global keep_running #result = draw_canny(data) data = frame_convert2.video_cv(data) result = data.copy() t_end = datetime.datetime.now() t_delta = t_end - t_start cv2.putText(result, str(1000000/t_delta.microseconds), (0, 25), cv2.FONT_HERSHEY_PLAIN, 2, (127, 0, 0), 2) cv2.imshow('RGB', result) if cv2.waitKey(10) == 27: keep_running = False
def kinect_run(): # ROS node setup pub = rospy.Publisher('Image_Screws', kinect_msg, queue_size=1) rospy.init_node('Kinect_Main', anonymous=True) rate = rospy.Rate(10) msg = kinect_msg() status = 3 # Current status = setting up try: im_screw_detect = ImScrewDetector() except Exception: print("**Screw Detect Error**") status = 0 traceback.print_exc(file=sys.stdout) while not rospy.is_shutdown(): try: image = np.array( frame_convert2.video_cv(freenect.sync_get_video()[0])) image = scale(image) status = 1 # Status ready except TypeError as e: time.sleep(1) except Exception as e: print("**Get Image Error**") status = 0 # error status traceback.print_exc(file=sys.stdout) break im_screw_states, tally = im_screw_detect.detect_screws( image, args.disp) im_screw_states = im_screw_states.tolist() # For each of 4 points, probability is each of 5 classes # ['screw_full', 'screw_empty', 'bolt_full', 'bolt_empty', 'null'] msg.im_screw_probs_1 = im_screw_states[0] msg.im_screw_probs_2 = im_screw_states[1] msg.im_screw_probs_3 = im_screw_states[2] msg.im_screw_probs_4 = im_screw_states[3] msg.tally = tally # Bolts and Screws Tally msg.im_stat = status # Vision status no. msg.safe_move = False # future use variable for robot pub.publish(msg) rate.sleep()
def doloop(c, conn, insert_snapshot): global depth, rgb, counter counter = 0 while True: # Get a fresh frame (depth, _) = get_depth() fn = './images/{}.png'.format(uuid4()) cv2.imwrite(fn, frame_convert2.video_cv(freenect.sync_get_video()[0])) # Build a two panel color image # d3 = np.dstack((depth,depth,depth)).astype(np.uint8) # da = np.hstack((d3,rgb)) # print(d3, rgb) # time.sleep(3) counter += 1 insert_snapshot(c, fn, depth) (ok, ) = c.execute('select count(1) from snapshot;') print(ok) conn.commit() time.sleep(1)
def rgb(dev, data, timestamp): global keep_running frame = frame_convert2.video_cv(data) _target = frame.copy() # find the horizontal centre pixel _center1 = np.uint16(np.round(frame.shape[1] / 2)) # find the vertical centre pixel _center2 = np.uint16(np.round(frame.shape[0] / 2)) cv2.circle(_target, (_center1, _center2), 2, (0, 0, 255), 3) # apply a red dot to the centre of the frame so the user can target the object to find HSV components from. cv2.imshow('RGB', _target) # show targeting frame in a window # Convert to HSV colourspace frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # find the Hue, Saturation, Value components of the frame CH_H, CH_S, CH_V = cv2.split(frame) if cv2.waitKey(10) == 27: # find Hue value of middle pixel pxl_H = CH_H[int(frame.shape[0] / 2), int(frame.shape[1] / 2)] # find Saturation value of middle pixel pxl_S = CH_S[int(frame.shape[0] / 2), int(frame.shape[1] / 2)] # find intensity value of middle pixel pxl_V = CH_V[int(frame.shape[0] / 2), int(frame.shape[1] / 2)] cv2.imwrite("measure_hsv.jpg", _target) print("Hue", pxl_H) print("Saturation", pxl_S) print("Intensity", pxl_V) keep_running = False
def get_video(): """ Get's the current video data from Kinect """ return frame_convert2.video_cv(freenect.sync_get_video()[0])
def get_rgb(): return imutils.rotate( frame_convert2.video_cv(freenect.sync_get_video()[0]), -90)
else: rate = rospy.Rate(1) if debug: Counter = 0 while not rospy.is_shutdown(): rate.sleep() if debug: if Counter % 100 == 0: print(Counter) #if Counter > 30: # break Counter += 1 depth, timestamp = freenect.sync_get_depth() #depth,safe = isBlocked(depth) video = frame_convert2.video_cv(freenect.sync_get_video()[0]) pub.publish(True) maskArray = k.findObjects(video) for mask in maskArray: keypointsArray, bluredIm = k.findBlobs(mask) #this is added up here becuase as part ofthis bluredIm goes from a 1 dimensional # ndarray to 3 channels which we need later # TODO Figure out how to do this without that. bluredIm = cv2.drawKeypoints( bluredIm, keypointsArray, np.array([]), (0, 0, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) cannyEdges = k.ourCannyBlob(mask) for point in keypointsArray: #try:
def get_video(): return frame_convert2.video_cv( freenect.sync_get_video_with_res( resolution=freenect.RESOLUTION_HIGH)[0])
def display_camera_reg(self, dev, data, timestamp): cv2.imshow('RGB', frame_convert2.video_cv(data)) if cv2.waitKey(1) == 27: self.keep_running = [False]
def show_video(): cv2.imshow('Video', frame_convert2.video_cv(freenect.sync_get_video()[0]))
return None diff = None lower = 0 upper = 100 max_upper = 1900 cv_prev_cx = 0 cv_prev_cy = 0 cv_prev_radius = 0 depth_area = 0 depth_x = 0 depth_y = 0 #freenect.set_depth_mode(freenect.RESOLUTION_MEDIUM,freenect.DEPTH_REGISTERED) while 1: while upper < max_upper: rgb = frame_convert2.video_cv(freenect.sync_get_video()[0]) rgb = rgb.astype(np.uint8) rgb_dil,rgb_mask = masking(rgb) depth, timestamp = freenect.sync_get_depth() #print('%d < depth < %d' % (lower, upper)) depth = disp_thresh(lower,upper,depth) mblur = cv2.medianBlur(depth, 15) apt_thresh = cv2.adaptiveThreshold(mblur, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 15, 5) canny = cv2.Canny(apt_thresh,100,255) dilate = cv2.dilate(canny, kernel=(3, 3), iterations=1) comb = cv2.bitwise_and(apt_thresh,rgb_mask) _, cnt, hierarchy = cv2.findContours(dilate, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) _,rgb_cnt,rgb_heir = cv2.findContours(rgb_dil,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) if rgb_cnt: epsilon = 0.1 * cv2.arcLength(rgb_cnt[0], True) approx = cv2.approxPolyDP(rgb_cnt[0], epsilon, True)
def display_rgb(dev, data, timestamp): global keep_running cv2.imshow('RGB', frame_convert2.video_cv(data)) if cv2.waitKey(10) == 27: keep_running = False
def show_video(): cv2.imshow('Video', frame_convert2.video_cv(frame))
def kinect_get_video(): # get the rgb image and make it correct format return frame_convert2.video_cv(freenect.sync_get_video()[0])
def get_circle_pos(data): """ Get's the x,y location of circles in the current frame """ frame = frame_convert2.video_cv(data) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # setup lower threshold masks for filtering (H,S,V) lower_red = np.array([165, 220, 50]) # setup upper threshold masks for filtering (H,S,V) upper_red = np.array([185, 255, 200]) # use higher than 180 hue to wrap around to 0 # cast to type that the opencv can process consistently lower = np.array(lower_red, dtype="uint8") upper = np.array(upper_red, dtype="uint8") _mask = cv2.inRange(frame, lower, upper) # find boolean mask for filtering # bitwise-and original frame using the mask above to find the filtered frame. frame = cv2.bitwise_and(frame, frame, mask=_mask) # convert filtered frame back to BGR colourspace (opencv likes BGR rather than RGB) frame = cv2.cvtColor(frame, cv2.COLOR_HSV2BGR) # CIRCLE DETECTION # convert to greyscale colourspace cimg = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # (optional: smooth image to reduce detection errors, must be an odd number) cimg = cv2.GaussianBlur(cimg, (9, 9), 0) circles = cv2.HoughCircles(cimg, cv2.HOUGH_GRADIENT, 1, 200, param1=40, param2=15, minRadius=1, maxRadius=50) # this function will need some tuning and trial & error, see the opencv documentation # if(circles != None): # if there are circle detected in the frame point = Point(0, 0) if circles is not None: circles = np.uint16(np.around(circles)) # loop through all the circles detected # for i in range(len(circles[0])): i = 0 point.x = circles[0][i][0] point.y = circles[0][i][1] # draw the outer circle cv2.circle(frame, (circles[0][i][0], circles[0][i][1]), circles[0][i][2], (0, 255, 0), 2) # draw the centre of the circle cv2.circle(frame, (circles[0][i][0], circles[0][i][1]), 2, (0, 0, 255), 3) # see documentation for draw functions else: point.x = -1 point.y = -1 # show frame in a separate window cv2.imshow('RGB', frame) return point
def doloop(): """ Primary process loop. """ global depth, rgb, current_target current_target = None positions = [] create_windows() nothing = lambda x: None # cv2.createTrackbar('distance min', 'color', 0, 255, nothing) # cv2.createTrackbar('distance max', 'color', 0, 255, nothing) cv2.createTrackbar('min', 'color', MIN_A, 500, nothing) cv2.createTrackbar('max', 'color', MAX_A, 1000, nothing) cv2.createTrackbar('trim', 'color', 0, 200, nothing) cv2.createTrackbar('user', 'grid', 0, 640, nothing) cv2.createTrackbar('difficulty', 'grid', 0, 4, nothing) #cv2.createTrackbar('Top Motor', 'grid', MOTOR1, 1023, nothing) #cv2.createTrackbar('Bottom Motor', 'grid', MOTOR2, 1023, nothing) cv2.createTrackbar('rotation', 'grid', 90, 180, nothing) times = [] while True: #time.sleep(1) start = time.time() # Trackbar updates distance_min = cv2.getTrackbarPos('distance min', 'color') distance_max = cv2.getTrackbarPos('distance max', 'color') min_a = cv2.getTrackbarPos('min', 'color') max_a = cv2.getTrackbarPos('max', 'color') trim = cv2.getTrackbarPos('trim', 'color') difficulty = cv2.getTrackbarPos('difficulty', 'grid') userpos = cv2.getTrackbarPos('user', 'grid') if distance_min == -1: distance_min = DISTANCE_MIN if distance_max == -1: distance_max = DISTANCE_MAX if min_a == -1: min_a = MIN_A if max_a == -1: max_a = MAX_A if trim == -1: trim = EDGE # Get a fresh frame (depth, _), (rgb, _) = get_depth(), get_video() depth = prepare_depth(depth) # Trim frame if trim: depth = depth[:, trim:depth.shape[1] - trim] rgb = rgb[:, trim:rgb.shape[1] - trim] # Threshold ret, thresh1 = cv2.threshold(depth, distance_min, 255, cv2.THRESH_TOZERO) ret, thresh = cv2.threshold(thresh1, distance_max, 255, cv2.THRESH_TOZERO_INV) if 'd' in windows: cv2.imshow('depth', depth) if 't' in windows: cv2.imshow('threshold', thresh) # Get target point contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) target = get_contour2(contours, min_a, max_a) if not target is None: M = cv2.moments(target) if M['m00'] == 0: print "0" else: target_point = (int(M['m10'] / M['m00']), int(M['m01'] / M['m00'])) x_val = (640.0 / float(target_point[0]) * 255) _, radius = cv2.minEnclosingCircle(target) #cv2.putText(rgb, str(radius), target_point, cv2.FONT_HERSHEY_SIMPLEX, \ #1, (0,255,0), 2, cv2.CV_AA) cv2.circle(rgb, target_point, 4, (255, 0, 0), -1) cv2.drawContours(rgb, [target], -1, (0, 255, 0), 3) if userpos == -1: userpos = target_point[0] #Clip userpos userpos = max(min(2 * userpos - WIDTH / 2, WIDTH), 0) if difficulty: current_target = pick_target(userpos, difficulty) current_speed = pick_speed(userpos, difficulty) # Keep a list of the detected positions positions.append(current_target) if len(positions) == 6: # select and send target send_target(select_target(positions, difficulty)) positions = [] if 'g' in windows: cv2.imshow('grid', drawTable(userpos, current_target)) if 'c' in windows: cv2.imshow('color', video_cv(rgb)) char = cv2.waitKey(10) if char == 27: cv2.destroyAllWindows() break elif char == 115: cv2.imwrite('capture.png', video_cv(rgb)) cv2.namedWindow('saved') cv2.imshow('saved', video_cv(rgb)) elif char == ord('r'): if serial_out: serial_out.close() serial_out.open() end = time.time() times.append(end - start)
def kinect_get_image(self): # im: A numpy array, shape:(480, 640, 3) dtype:np.uint8 # timestamp: int representing the time img, timestamp = freenect.sync_get_video() return frame_convert2.video_cv(img)
def show_depth(warp=False): global threshold global current_depth global last_image global client global last_note depth, timestamp = freenect.sync_get_depth() rgb = frame_convert2.video_cv(freenect.sync_get_video()[0]) depth = 255 * np.logical_and(depth >= current_depth - threshold, depth <= current_depth + threshold) depth = depth.astype(np.uint8) depth_rgb = cv2.cvtColor(depth, cv2.COLOR_GRAY2RGB) # kernel = np.ones((9,9), np.uint8) # depth_rgb = cv2.dilate(depth_rgb, kernel, iterations=1) # depth_rgb = cv2.erode(depth_rgb, kernel, iterations=1) hSobel = cv2.Sobel(depth_rgb, cv2.CV_32F, 0, 1, -1) vSobel = cv2.Sobel(depth_rgb, cv2.CV_32F, 1, 0, -1) depth_rgb = cv2.add(hSobel, vSobel) depth_rgb = cv2.convertScaleAbs(depth_rgb) depth_rgb = cv2.GaussianBlur(depth_rgb, (3, 3), 0) ret, depth_rgb = cv2.threshold(depth_rgb, 80, 255, cv2.THRESH_BINARY) # depth_rgb_mask = cv2.cvtColor(depth, cv2.COLOR_GRAY2RGB) # depth_rgb = cv2.bitwise_and(rgb,rgb,mask = depth) h, w = depth.shape[:2] # img = cv2.GaussianBlur(depth_rgb,(3,3),0) # laplacian = cv2.Laplacian(img,cv2.CV_8U) if (not last_image is None): x_offset = int(w * (scale - 1.0) / 2.0) y_offset = int(h * (scale - 1.0) / 2.0) scaled = cv2.resize(last_image, None, fx=scale, fy=scale)[y_offset:h + y_offset, x_offset:w + x_offset] color_img = np.zeros((h, w, 3), dtype=np.uint8) color_img[:, :] = [ random.randint(1, 255), random.randint(1, 255), random.randint(1, 255) ] color_scale = cv2.bitwise_and(color_img, scaled) image = cv2.bitwise_or(color_scale, depth_rgb) # image = depth_rgb # overlay = cv2.bitwise_xor(rgb, image) # cv2.line(image, (0, y_threshold), (w, y_threshold), (0, 255, 0), 3) # overlay_with_keypoints = cv2.drawKeypoints(overlay, keypoints, np.array([]), (0, 0, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) if False: params = cv2.SimpleBlobDetector_Params() params.minThreshold = 0 params.maxThreshold = 255 params.minArea = 200 params.maxArea = w * h params.filterByArea = True params.filterByCircularity = False params.filterByConvexity = False params.filterByColor = False params.filterByInertia = False detector = cv2.SimpleBlobDetector_create(params) keypoints = detector.detect(depth) print("Detected " + str(len(keypoints))) for keypoint in keypoints: cX = int(keypoint.pt[0]) cY = int(keypoint.pt[1]) location = str(cX) + "," + str(cY) cv2.circle(image, (cX, cY), 15, (255, 0, 255), -1) cv2.putText(image, location, (cX - 25, cY - 25), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 2) # if(last_note >= 0): # # Already playing a note # if(cY > y_threshold): # # Center is below line, stop playing # client.publish("note-off", last_note) # last_note = -1 # else: # # Center is still above the line, leave current note # client.publish("note-off", last_note) # note = int(map_range((0, w), (88, 0), cX)) # # Only change if we've moved by 2 semitones # if(abs(note - last_note) > 2): # last_note = note # client.publish("note-on", note) # pass # else: # # No active note # if(cY < y_threshold): # # Center is above the line, start a new note # note = int(map_range((0, w), (88, 0), cX)) # last_note = note # client.publish("note-on", note) # else: # # Center is below the line, don't start anything # pass if (warp): src = np.array([[0, 0], [w - 1, 0], [w - 1, h - 1], [0, h - 1]], dtype="float32") dst = np.array( [[150, 50], [w - 1, 0], [w - 1, h - 1], [150, h - 51]], dtype="float32") M = cv2.getPerspectiveTransform(src, dst) warped = cv2.warpPerspective(overlay, M, (w, h)) cv2.imshow('Depth', warped) else: # cv2.imshow('Depth', overlay) cv2.imshow('Depth', image) last_image = image else: last_image = depth_rgb
def get_video(): f = frame_convert2.video_cv(freenect.sync_get_video()[0]) return cv2.fastNlMeansDenoisingColored(f, None, 10, 10, 3, 3)
def get_video(): return frame_convert2.video_cv(freenect.sync_get_video()[0])
def get_video(): frame = frame_convert2.video_cv(freenect.sync_get_video()[0]) #print('\nframeVideo =\n') #print(frame) return frame