def show_frame(self): color_image = cv.QueryFrame(self.capture) color_image1 = cv.CreateImage(cv.GetSize(color_image), 8, 3) grey_image = cv.CreateImage(cv.GetSize(color_image), cv.IPL_DEPTH_8U, 1) moving_average = cv.CreateImage(cv.GetSize(color_image), cv.IPL_DEPTH_32F, 3) grey = cv.CreateImage(cv.GetSize(color_image), 8, 3) HSV = cv.CreateImage(cv.GetSize(color_image), 8, 3) red = cv.CreateImage(cv.GetSize(color_image), 8, 3) cv.CvtColor(color_image, grey, cv.CV_RGB2HLS) cv.CvtColor(color_image, HSV, cv.CV_RGB2HSV) cv.Not(color_image, red) cv.ShowImage(self.window1, color_image) cv.ShowImage(self.window2, grey) cv.ShowImage(self.window3, HSV) cv.ShowImage(self.window4, red) cv.MoveWindow(self.window1, 30, 120) cv.MoveWindow(self.window2, 430, 120) cv.MoveWindow(self.window3, 430, 470) cv.MoveWindow(self.window4, 30, 470) while self.arduino.inWaiting() > 0: self.data += self.arduino.read(1)
def __init__(self, node_name): ROS2OpenCV2.__init__(self, node_name) self.node_name = node_name # The minimum saturation of the tracked color in HSV space, # as well as the min and max value (the V in HSV) and a # threshold on the backprojection probability image. self.smin = rospy.get_param("~smin", 85) self.vmin = rospy.get_param("~vmin", 50) self.vmax = rospy.get_param("~vmax", 254) self.threshold = rospy.get_param("~threshold", 50) # Create a number of windows for displaying the histogram, # parameters controls, and backprojection image cv.NamedWindow("Histogram", cv.CV_WINDOW_NORMAL) cv.MoveWindow("Histogram", 700, 50) cv.NamedWindow("Parameters", 0) cv.MoveWindow("Parameters", 700, 325) cv.NamedWindow("Backproject", 0) cv.MoveWindow("Backproject", 700, 600) # Create the slider controls for saturation, value and threshold cv.CreateTrackbar("Saturation", "Parameters", self.smin, 255, self.set_smin) cv.CreateTrackbar("Min Value", "Parameters", self.vmin, 255, self.set_vmin) cv.CreateTrackbar("Max Value", "Parameters", self.vmax, 255, self.set_vmax) cv.CreateTrackbar("Threshold", "Parameters", self.threshold, 255, self.set_threshold) # Initialize a number of variables self.hist = None self.track_window = None self.show_backproj = False
def __init__(self): self.t = TurtleBotMove() self.node_name = "testDriveDemo" # rospy.init_node(self.node_name) # What we do during shutdown rospy.on_shutdown(self.cleanup) # Create the OpenCV display window for the RGB image self.cv_window_name = self.node_name cv.NamedWindow(self.cv_window_name, cv.CV_WINDOW_NORMAL) cv.MoveWindow(self.cv_window_name, 25, 75) # And one for the depth image cv.NamedWindow("Depth Image", cv.CV_WINDOW_NORMAL) cv.MoveWindow("Depth Image", 25, 350) # Create the cv_bridge object self.bridge = CvBridge() # Subscribe to the camera image and depth topics and set # the appropriate callbacks self.image_sub = rospy.Subscriber("/camera/rgb/image_raw", Image, self.image_callback) self.depth_sub = rospy.Subscriber("/camera/depth/image_raw", Image, self.depth_callback) rospy.loginfo("Waiting for image topics...")
def __init__(self): self.node_name = "cv_bridge_demo" rospy.init_node(self.node_name) # 关闭 rospy.on_shutdown(self.cleanup) # 创建 rgb图像 显示窗口 self.cv_window_name = self.node_name cv.NamedWindow(self.cv_window_name, cv.CV_WINDOW_NORMAL) cv.MoveWindow(self.cv_window_name, 25, 75) # 创建深度图像显示窗口 cv.NamedWindow("Depth Image", cv.CV_WINDOW_NORMAL) cv.MoveWindow("Depth Image", 25, 350) # 创建 ros 图 到 opencv图像转换 对象 self.bridge = CvBridge() # 订阅 深度图像和rgb图像数据发布的话题 以及定义 回调函数 # the appropriate callbacks self.image_sub = rospy.Subscriber("input_rgb_image", Image, self.image_callback, queue_size=1) self.depth_sub = rospy.Subscriber("input_depth_image", Image, self.depth_callback, queue_size=1) # 登陆信息 rospy.loginfo("Waiting for image topics...") rospy.wait_for_message("input_rgb_image", Image) rospy.loginfo("Ready.")
def __init__(self): self.node_name = "cv_bridge_demo" rospy.init_node(self.node_name) # What we do during shutdown rospy.on_shutdown(self.cleanup) # Create the OpenCV display window for the RGB image self.cv_window_name = self.node_name cv.NamedWindow(self.cv_window_name, cv.CV_WINDOW_NORMAL) cv.MoveWindow(self.cv_window_name, 25, 75) # And one for the depth image cv.NamedWindow("Depth Image", cv.CV_WINDOW_NORMAL) cv.MoveWindow("Depth Image", 25, 350) # Create the cv_bridge object self.bridge = CvBridge() # Subscribe to the camera image and depth topics and set # the appropriate callbacks self.image_sub = rospy.Subscriber("/camera/rgb/image_color", Image, self.image_callback, queue_size=1) self.depth_sub = rospy.Subscriber("/camera/depth_registered/image", Image, self.depth_callback, queue_size=1) rospy.loginfo("Waiting for image topics...") rospy.wait_for_message("input_rgb_image", Image) rospy.loginfo("Ready.")
def close_adaptive(self, frame): #Gray Scale frame = cv2.GaussianBlur(frame, (3,3),2) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) ##Morphological Operations kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(2,2)) gray = cv2.morphologyEx(gray, cv2.MORPH_OPEN, kernel, iterations=2) gray = cv2.morphologyEx(gray, cv2.MORPH_CLOSE, kernel,iterations=5) ##Creating a copy to draw on overlayed = frame #getting size of image m,n = gray.shape #Adaptive Thresholding edges = cv2.adaptiveThreshold(gray,self.a_maxval,self.a_method,self.a_threshtype,self.a_block_size,self.a_constant) if self.debug_mode: cv.NamedWindow("Gray", 0) cv.MoveWindow("Gray", 0, 0) cv2.imshow("Gray", gray) cv.NamedWindow("Edges", 0) cv.MoveWindow("Edges", 330, 0) cv2.imshow("Edges", edges) return edges
def __init__(self): self.node_name = "turtlebot_openCV" rospy.init_node(self.node_name) # Create the OpenCV display window for the RGB image cv.NamedWindow("Color Image", cv.CV_WINDOW_NORMAL) cv.MoveWindow("Color Image", 25, 75) # And one for the depth image cv.NamedWindow("Depth Image", cv.CV_WINDOW_NORMAL) cv.MoveWindow("Depth Image", 25, 350) # Create the cv_bridge object self.bridge = CvBridge() # Subscribe to the camera image and depth topics and set # the appropriate callbacks self.image_sub = rospy.Subscriber("input_rgb_image", Image, self.image_callback, queue_size=1) self.depth_sub = rospy.Subscriber("input_depth_image", Image, self.depth_callback, queue_size=1)
def show_camera_and_get_images(capture, laser_ctrl, mapx=None, mapy=None): while 1: img, k = show_camera_and_wait_for_key(capture, 5, mapx, mapy) if k >= 0: img1, img2 = get_images(capture, laser_ctrl, mapx, mapy) cv.NamedWindow('img1', cv.CV_WINDOW_AUTOSIZE) cv.NamedWindow('img2', cv.CV_WINDOW_AUTOSIZE) cv.ShowImage('img1', img1) cv.ShowImage('img2', img2) cv.MoveWindow('img1', 10, 10) cv.MoveWindow('img2', 660, 10) return img1, img2
def __init__(self): self.node_name = "line_follower_turtlebot" rospy.init_node(self.node_name) rospy.on_shutdown(self.cleanup) # Determine size of window size and name self.cv_window_name = self.node_name cv.NamedWindow(self.cv_window_name, cv.CV_WINDOW_NORMAL) cv.MoveWindow(self.cv_window_name, 25, 75) # Create the cv_bridge object self.bridge = CvBridge() # Subscribe to the Camera Image Raw self.image_sub = rospy.Subscriber("/camera/rgb/image_raw", Image, self.image_callback, queue_size=1) # Publish to Robot Velocity self.pub = rospy.Publisher('/cmd_vel_mux/input/teleop', Twist, queue_size=1) self.rate = rospy.Rate(10) #Login Info rospy.loginfo("Bela Ciao") rospy.wait_for_message("/camera/rgb/image_raw", Image) rospy.loginfo("Line Following Turtlebot")
def __init__(self): self.demo_on = False self.node_name = "walle_recognizer" rospy.init_node(self.node_name) # What we do during shutdown rospy.on_shutdown(self.cleanup) # Create the OpenCV display window for the RGB image self.cv_window_name = self.node_name cv.NamedWindow("RGB Image", cv.CV_WINDOW_NORMAL) cv.MoveWindow("RGB Image", 25, 75) # And one for the depth image cv.NamedWindow("Depth Image", cv.CV_WINDOW_NORMAL) cv.MoveWindow("Depth Image", 25, 350) self.known_objects = [] self.sift = cv2.ORB() self.current_depth = None # self.current_color = None self.current_stage = None # Create the cv_bridge object self.bridge = CvBridge() self.pub = rospy.Publisher("/walle/recognizer/publish", String) self.rate = rospy.Rate(10) # 10hz self.last_recognized = None # Subscribe to the camera image and depth topics and set # the appropriate callbacks self.image_sub = rospy.Subscriber("/camera/rgb/image_color", Image, self.image_callback) self.depth_sub = rospy.Subscriber("/camera/depth/image_raw", Image, self.depth_callback) rospy.Subscriber("/walle/recognizer/listen", String, self.receive, queue_size=1) rospy.loginfo("Waiting for image topics...")
def __init__(self, node_name): ROS2OpenCV2.__init__(self, node_name) self.node_name = node_name self.color_under_detect = rospy.get_param("~color_under_detect", "red") # call masking alglorthm to get the color mask self.mymask = Masking(color=self.color_under_detect, shape="triangle", masker=None, detector=None, matcher=None, matching_method=None) # The minimum saturation of the tracked color in HSV space, # as well as the min and max value (the V in HSV) and a # threshold on the backprojection probability image. self.smin = rospy.get_param("~smin", 85) self.vmin = rospy.get_param("~vmin", 50) self.vmax = rospy.get_param("~vmax", 254) self.threshold = rospy.get_param("~threshold", 50) # Create a number of windows for displaying the histogram, # parameters controls, and backprojection image cv.NamedWindow("Histogram", cv.CV_WINDOW_NORMAL) cv.MoveWindow("Histogram", 700, 50) cv.NamedWindow("Parameters", 0) cv.MoveWindow("Parameters", 700, 325) cv.NamedWindow("Backproject", 0) cv.MoveWindow("Backproject", 700, 600) cv.NamedWindow("Tracked_obj", 0) cv.MoveWindow("Tracked_obj", 1000, 50) # Create the slider controls for saturation, value and threshold cv.CreateTrackbar("Saturation", "Parameters", self.smin, 255, self.set_smin) cv.CreateTrackbar("Min Value", "Parameters", self.vmin, 255, self.set_vmin) cv.CreateTrackbar("Max Value", "Parameters", self.vmax, 255, self.set_vmax) cv.CreateTrackbar("Threshold", "Parameters", self.threshold, 255, self.set_threshold) # Initialize a number of variables self.hist = None self.track_window = None self.show_backproj = False
def __init__(self): self.node_name="cv_bridge_demo" rospy.init_node(self.node_name) rospy.on_shutdown(self.cleanup) self.cv_window_name=self.node_name cv.NamedWindow(self.cv_window_name,cv.CV_WINDOW_NORMAL) cv.MoveWindow(self.cv_window_name,25,75) cv.NamedWindow("Depth Image",cv.CV_WINDOW_NORMAL) cv.MoveWindow("depth Image",25,350) self.bridge = CvBridge() self.image_sub= rospy.Subscriber("/camera/rgb/image_color",Image,self.image_callback) self.depth_sub= rospy.Subscriber("/camera/depth/image_raw",Image,self.depth_callback) rospy.loginfo("Waiting for image topic...")
def cam_shift(self, frame): # First blue the image blur = cv2.blur(frame, (5, 5)) # Convert from RGB to HSV spave hsv = cv2.cvtColor(blur, cv2.COLOR_BGR2HSV) # Create a mask using the current saturation and value parameters mask = cv2.inRange(hsv, np.array((38., self.smin, self.vmin)), np.array((75., 250., self.vmax))) x0, y0, w, h = [0,0,320,240] x1 = x0 + w y1 = y0 + h self.track_window = (x0, y0, x1, y1) hsv_roi = hsv[y0:y1, x0:x1] mask_roi = mask[y0:y1, x0:x1] self.hist = cv2.calcHist( [hsv_roi], [0], mask_roi, [16], [0, 180] ) cv2.normalize(self.hist, self.hist, 0, 255, cv2.NORM_MINMAX); self.hist = self.hist.reshape(-1) self.show_hist() # If we have a histogram, tracking it with CamShift if self.hist is not None: # Compute the backprojection from the histogram backproject = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1) # Mask the backprojection with the mask created earlier backproject &= mask # Threshold the backprojection ret, backproject = cv2.threshold(backproject, self.threshold, 255, cv.CV_THRESH_TOZERO) x, y, w, h = self.track_window if self.track_window is None or w <= 0 or h <=0: self.track_window = 0, 0, self.frame_width - 1, self.frame_height - 1 # Set the criteria for the CamShift algorithm term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 ) # Run the CamShift algorithm self.track_box, self.track_window = cv2.CamShift(backproject, self.track_window, term_crit) kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(2,2)) backproject = cv2.morphologyEx(backproject, cv2.MORPH_CLOSE, kernel,iterations=20) if self.debug_mode: # Display the resulting backprojection cv.NamedWindow("Backproject", 0) cv.MoveWindow("Backproject", 0, 240) cv2.imshow("Backproject", backproject) return backproject
def __init__(self, name, start_values): self.name = name cv.NamedWindow(name, flags=cv.CV_WINDOW_NORMAL) cv.MoveWindow(name, 20, 20) assert len(start_values) == 6 self.values = OrderedDict() for channel, value in start_values.items(): self.values[channel] = value cv.CreateTrackbar(channel, name, value, 255, self.make_modifier(channel))
def __init__(self): self.node_name = 'cv_bridge_demo' rospy.init_node(self.node_name) #what we do during shutdown rospy.on_shutdown(self.cleanup) #create the opencv display window for the rgb image self.cv_window_name = self.node_name cv.NamedWindow(self.cv_window_name,cv.CV_WINDOW_NORMAL) cv.MoveWindow(self.cv_window_name,25,75) # and one for the depth image cv.NamedWindow("depth image",cv.CV_WINDOW_NORMAL) cv.MoveWindow('depth image',25,300) # create the cv_bridge object self.bridge = CvBridge() # subscribe to the camera image and depth topics and set # the appropriate callbacks self.image_sub = rospy.Subscriber('/camera/rgb/image_color',Image,self.image_callback) self.depth_sub = rospy.Subcriber('/camera/depth_registered/image_rect',Image,self.depth_callback) rospy.loginfo("waiting for the image topics...")
def __init__(self): self.node_name = "cv_bridge_demo" #Initialize the ros node rospy.init_node(self.node_name) # What we do during shutdown # Create the OpenCV display window for the RGB image self.cv_window_name = self.node_name cv.NamedWindow(self.cv_window_name, cv.CV_WINDOW_NORMAL) cv.MoveWindow(self.cv_window_name, 25, 75) # Create the cv_bridge object self.bridge = CvBridge() # Subscribe to the camera image and depth topics and set # the appropriate callbacks self.image_sub = rospy.Subscriber("/camera/rgb/image_rect_color", Image, self.image_callback) self.image_pub = rospy.Publisher("image_mask", Image) rospy.loginfo("Waiting for image topics...")
def single_measure_gui(): #setup capture, mapx, mapy = init_capture_device(capture_device) laser_controller = init_laser_controller(laser_controller_port) setup_camera_window() #get images and calculate distance img1, img2 = show_camera_and_get_images(capture, laser_controller, mapx, mapy) distance, posX, posY, area = measure_distance_from_images(img1, img2) #output r_img = result_image(img2, posX, posY, distance) cv.MoveWindow('res', 10, 10) cv.ShowImage('res', r_img) cv.SaveImage("img1.jpg", img1) cv.SaveImage("img2.jpg", r_img) print "%0.2f,%d,%d,%d" % (distance, posX, posY, area) cv.WaitKey(50000)
def __init__(self): self.node_name = "cv_bridge_demo" rospy.init_node(self.node_name) # What we do during shutdown rospy.on_shutdown(self.cleanup) # Create the OpenCV display window for the RGB image self.cv_window_name = self.node_name cv.NamedWindow(self.cv_window_name, cv.CV_WINDOW_NORMAL) cv.MoveWindow(self.cv_window_name, 25, 75) # And one for the depth image self.target_visible = False self.tl = tf.TransformListener() self.xt = -1 self.yt = -1 self.w = -1 self.i = -1 self.j = -1 self.k = -1 self.yaw = -1; self.roll= -1; self.pitch = -1; self.MarkId = -1; # Create the cv_bridge object self.bridge = CvBridge() self.arList = [] # Subscribe to the camera image and depth topics and set # the appropriate callbacks self.image_sub = rospy.Subscriber("/camera/rgb/image_color", Image, self.image_callback) self.ar_sub = rospy.Subscriber('ar_pose_marker', AlvarMarkers, self.registerAR_cb) self.is_visible = False; rospy.loginfo("Waiting for image topics...")
def __init__(self, node_name): ROS2OpenCV2.__init__(self, node_name) self.node_name = node_name self.match_threshold = rospy.get_param("~match_threshold", 0.7) self.find_multiple_targets = rospy.get_param("~find_multiple_targets", False) self.n_pyr = rospy.get_param("~n_pyr", 2) self.min_template_size = rospy.get_param("~min_template_size", 25) self.scale_factor = rospy.get_param("~scale_factor", 1.2) self.scale_and_rotate = rospy.get_param("~scale_and_rotate", False) self.use_depth_for_detection = rospy.get_param("~use_depth_for_detection", False) self.fov_width = rospy.get_param("~fov_width", 1.094) self.fov_height = rospy.get_param("~fov_height", 1.094) self.max_object_size = rospy.get_param("~max_object_size", 0.28) # The minimum saturation of the tracked color in HSV space, # as well as the min and max value (the V in HSV) and a # threshold on the backprojection probability image. self.smin = rospy.get_param("~smin", 85) self.vmin = rospy.get_param("~vmin", 50) self.vmax = rospy.get_param("~vmax", 254) self.threshold = rospy.get_param("~threshold", 50) # Create a number of windows cv.NamedWindow("Backproject", 0) cv.MoveWindow("Backproject", 700, 600) # Initialize a number of variables self.hist = None self.track_window = None self.show_backproj = False self.detector_loaded = False
def __init__(self): self.node_name = "cv_bridge_demo" rospy.init_node(self.node_name) # What we do during shutdown rospy.on_shutdown(self.cleanup) # Create the OpenCV display window for the RGB image self.cv_window_name = self.node_name cv2.NamedWindow(self.cv_window_name, cv2.CV_WINDOW_NORMAL) cv2.MoveWindow(self.cv_window_name, 25, 75) # Create the cv_bridge object self.bridge = CvBridge() # Subscribe to the camera image and depth topics and set # the appropriate callbacks self.image_sub = rospy.Subscriber("/usb_cam/image_raw", Image, self.image_callback, queue_size=1) rospy.loginfo("Waiting for image topics...") rospy.wait_for_message("/usb_cam/image_raw", Image) rospy.loginfo("Ready.")
def prob_hough(self, frame): overlayed = frame #Probabilistic Line Detection plines = cv2.HoughLinesP(frame, self.h_rho, np.pi/self.h_theta, self.h_thresh, np.array([]), self.h_minlinelength)[0] print plines # Draw Red lines for l in plines[:1]: cv2.line(overlayed, (l[0],l[1]), (l[2],l[3]), (0,0,255), 2) x = (l[2]-l[0])+l[0]/2 y = (l[1]+l[3])/2 print "x = %d & y = %d" % (x , y) # Debugging Windows if self.debug_mode: cv.NamedWindow("Hough", 0) cv.MoveWindow("Hough", 660, 0) cv2.imshow("Hough", overlayed)
print "Giving up trying to set camera settings. Retry a few times, fix it or run with --disable-cam-settings" sys.exit(1) cap = cap_camera(int(args.cam)) elif args.file: cap = cap_file(args.file) else: raise ValueError("Must specify either --cam or --file!") detector_state = DetectorState((640, 480), 128, 5, approx_object_size=15.0) d = OrderedDict([('h_low', 0), ('h_high', 255), ('s_low', 0), ('s_high', 255), ('v_low', 0), ('v_high', 255)]) white_sample = threshold.Threshold("white_sample", d) cv.NamedWindow("image", flags=cv.CV_WINDOW_NORMAL) cv.MoveWindow("image", 20, 20) cv.ResizeWindow("image", 700, 700) cv.NamedWindow("original", flags=cv.CV_WINDOW_NORMAL) cv.MoveWindow("original", 650, 20) cv.ResizeWindow("original", 640, 480) cv.NamedWindow("heuristics", flags=cv.CV_WINDOW_NORMAL) cv.MoveWindow("heuristics", 400, 400) cv.ResizeWindow("heuristics", 640, 480) heuristics = HeuristicStack({ (PhysicalSizeHeuristic(debug=False), 1.0), #(LargestHeuristic(debug=False), 0.5), (NormalBlobSizeHeuristic(debug=False), 0.5), (DensityHeuristic2(debug=False), 0.5)
def __init__(self, camera_num, debug = False): """ Here all needed variables and data is initialized This function is run when starting """ global cam #Initialize the camera and its values, Get the first frame cam = cv2.VideoCapture(camera_num) self.cam_width = cam.set(cv.CV_CAP_PROP_FRAME_WIDTH, 320) self.cam_height = cam.set(cv.CV_CAP_PROP_FRAME_HEIGHT, 240) self.cam_width = cam.get(cv.CV_CAP_PROP_FRAME_WIDTH) self.cam_height = cam.get(cv.CV_CAP_PROP_FRAME_HEIGHT) self.debug = debug retval, self.frame = cam.read() self.count = 0 #Create windows to show videoprocessing if self.debug: cv2.namedWindow( "Camera", cv.CV_WINDOW_AUTOSIZE ) cv.MoveWindow('Camera', 450, 0) cv2.namedWindow( "Thresholded", cv.CV_WINDOW_AUTOSIZE ) cv.MoveWindow("Thresholded", 450,350) cv2.namedWindow( "contour", cv.CV_WINDOW_AUTOSIZE ) cv.MoveWindow("contour", 0,350) """ Import the threshold values that are set by the thresholds.py program """ thresholdvalues="" try: f = open('thresholdvalues.txt', 'r') thresholdvalues = f.read() f.close() except: print "No threshold values found. Creating blank list" for i in range(36): thresholdvalues+="0 " clrs=thresholdvalues.split() for i in range(len(clrs)): clrs[i]=int(clrs[i]) #Choose the thresholds (variable names speak for them self) self.ball_threshold_low = np.asarray([clrs[0],clrs[1],clrs[2]], np.uint8) self.ball_threshold_high = np.asarray([clrs[3],clrs[4],clrs[5]], np.uint8) self.blue_gate_threshold_low = np.asarray([clrs[6],clrs[7],clrs[8]], np.uint8) self.blue_gate_threshold_high = np.asarray([clrs[9],clrs[10],clrs[11]], np.uint8) self.yellow_gate_threshold_low = np.asarray([clrs[12],clrs[13],clrs[14]], np.uint8) self.yellow_gate_threshold_high =np.asarray([clrs[15],clrs[16],clrs[17]], np.uint8) self.black_threshold_low = np.asarray([clrs[18],clrs[19],clrs[20]], np.uint8) self.black_threshold_high = np.asarray([clrs[21],clrs[22],clrs[23]], np.uint8) self.white_threshold_low = np.asarray([clrs[24],clrs[25],clrs[26]], np.uint8) self.white_threshold_high = np.asarray([clrs[27],clrs[28],clrs[29]], np.uint8) self.green_threshold_low = np.asarray([clrs[30],clrs[31],clrs[32]], np.uint8) self.green_threshold_high = np.asarray([clrs[33],clrs[34],clrs[35]], np.uint8) #Buffer self.buffer = FrameBufferThread() self.buffer.daemon = True self.buffer.start()
for i in range(4): cv.Smooth(dst,smoothed,cv.CV_BILATERAL, 30,1,32,32) cv.Smooth(smoothed,dst,cv.CV_BILATERAL, 30,1,32,32) cv.Smooth(dst,smoothed,cv.CV_BILATERAL, 30,1,32,32) lap = cv.CreateImage(cv.GetSize(smoothed), cv.IPL_DEPTH_16S, 3) #laplace = cv.Laplace(smoothed, lap) gray = cv.CreateImage(cv.GetSize(smoothed), 8, 1) canny = cv.CreateImage(cv.GetSize(smoothed), 8, 1) cv.CvtColor(smoothed, gray, cv.CV_BGR2GRAY) cv.Canny(gray,canny,20,20,3) #ret,thresh = cv.threshold(imgray,127,255,0) cv.NamedWindow('Original') cv.MoveWindow('Original', 10, 10) cv.ShowImage('Original', im) cv.NamedWindow('Smoothed') cv.MoveWindow('Smoothed', 600, 100) cv.ShowImage('Smoothed',smoothed) cv.NamedWindow('Laplace') cv.MoveWindow('Laplace', 600, 100) cv.ShowImage('Canny',canny) cv.ShowImage('Gray',gray) cv.WaitKey(0) #cv.SaveImage("smoothed.png",dst) #dst = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_16S, 3) #cv.SaveImage("foo-laplace.png", lap)
def __init__(self): self.node_name = "parameter_calibration" rospy.init_node(self.node_name) # What we do during shutdown rospy.on_shutdown(self.cleanup) # Create the OpenCV display window for the RGB image self.cv_window_name = self.node_name cv.NamedWindow(self.cv_window_name, cv.CV_WINDOW_NORMAL) cv.MoveWindow(self.cv_window_name, 25, 75) # Create the cv_bridge object self.bridge = CvBridge() # Initialize necessary parameters self.frame_size = None self.frame_width = None self.frame_height = None self.mask = None self.cameraMatrix = np.array([ (2529.3016912669586, 0.0, 1007.0532160786125), (0.0, 2524.6309899852313, 650.2969085717225), (0.0, 0.0, 1.0) ]) self.distCoeffs = np.array([ -0.006795069030464255, -0.5045652004390003, 0.004947680741251182, 0.005813011948658337, 0.0 ]) self.projectionMatrix = np.array([ (2494.93408203125, 0.0, 1015.7040773447079, 0.0), (0.0, 2516.773681640625, 652.354580721294, 0.0), (0.0, 0.0, 1.0, 0.0) ]) # Filter parameters self.medianBlur_ksize = rospy.get_param("~medianBlur_ksize", 3) self.GaussianBlur_ksize_width = rospy.get_param( "~GaussianBlur_ksize_width", 5) self.GaussianBlur_ksize_height = rospy.get_param( "~GaussianBlur_ksize_height", 5) self.GaussianBlur_sigmaX = rospy.get_param("~GaussianBlur_sigmaX", 0) self.GaussianBlur_sigmaY = rospy.get_param("~GaussianBlur_sigmaY", 0) self.Canny_threshold1 = rospy.get_param("~Canny_threshold1", 90) self.Canny_threshold2 = rospy.get_param("~Canny_threshold2", 15) self.Canny_apertureSize = rospy.get_param("~Canny_apertureSize", 3) self.Canny_L2gradient = rospy.get_param("~L2gradient", False) # Store all the feature parameters together for passing to filters self.medianBlur_params = dict(ksize=self.medianBlur_ksize) self.GaussianBlur_params = dict(ksize=(self.GaussianBlur_ksize_width, self.GaussianBlur_ksize_height), sigmaX=self.GaussianBlur_sigmaX, sigmaY=self.GaussianBlur_sigmaY, borderType=BORDER_DEFAULT) self.Canny_params = dict(threshold1=self.Canny_threshold1, threshold2=self.Canny_threshold2, apertureSize=self.Canny_apertureSize, L2gradient=self.Canny_L2gradient) # Create an image publisher to ouput processed image self.image_pub = rospy.Publisher("processed_image", Image) # Subscribe to the camera image and depth topics and set the appropriate callbacks self.image_sub = rospy.Subscriber("input_rgb_image", Image, self.image_callback, queue_size=1) rospy.loginfo("Waiting for image topics...") rospy.wait_for_message("input_rgb_image", Image) rospy.loginfo("Ready.")
#! /usr/bin/env python import cv2.cv as cv cap = cv.CreateFileCapture("../c/tree.avi") img = cv.QueryFrame(cap) print "Got frame of dimensions (", img.width, " x ", img.height, ")" cv.NamedWindow("win", cv.CV_WINDOW_AUTOSIZE) cv.ShowImage("win", img) cv.MoveWindow("win", 200, 200) cv.WaitKey(0) cv.DestroyAllWindows()
def __init__(self, node_name): self.node_name = node_name rospy.init_node(node_name) rospy.loginfo("Starting node " + str(node_name)) rospy.on_shutdown(self.cleanup) self.drink_type="" self._wake=0 # Initialize the Region of Interest and its publisher self.ROI = RegionOfInterest() self.roi_pub = rospy.Publisher("/roi", RegionOfInterest, queue_size=1) self.dis_pub = rospy.Publisher("dist", Int32, queue_size=1) self.drink_ = rospy.Subscriber('drink_type',String,self.callbackDrink) self.wake_ = rospy.Subscriber('ros2_wake',Int32,self.callbackWake) self.hmin = rospy.get_param("~hmin", 22) self.hmax = rospy.get_param("~hmax", 62) self.smin = rospy.get_param("~smin", 115) self.smax = rospy.get_param("~smax", 255) self.vmin = rospy.get_param("~vmin", 50) self.vmax = rospy.get_param("~vmax", 255) ###### while self._wake!=1: rospy.sleep(1) if self.drink_type == '雪碧': #blue self.hmin = rospy.get_param("~hmin", 122) self.hmax = rospy.get_param("~hmax", 157) self.smin = rospy.get_param("~smin", 59) self.smax = rospy.get_param("~smax", 255) self.vmin = rospy.get_param("~vmin", 59) self.vmax = rospy.get_param("~vmax", 255) rospy.loginfo("匹配雪碧") if self.drink_type == '橙汁': #yellow self.hmin = rospy.get_param("~hmin", 70) self.hmax = rospy.get_param("~hmax", 155) self.smin = rospy.get_param("~smin", 90) self.smax = rospy.get_param("~smax", 255) self.vmin = rospy.get_param("~vmin", 50) self.vmax = rospy.get_param("~vmax", 255) rospy.loginfo("匹配橙汁") if self.drink_type == '可乐': #red self.hmin = rospy.get_param("~hmin", 155) self.hmax = rospy.get_param("~hmax", 190) self.smin = rospy.get_param("~smin", 67) self.smax = rospy.get_param("~smax", 224) self.vmin = rospy.get_param("~vmin", 83) self.vmax = rospy.get_param("~vmax", 223) rospy.loginfo("匹配可乐") ###### #self.show_text=rospy.get_param("~show_text",True) # Initialize a number of global variables self.frame = None self.frame_size = None self.frame_width = None self.frame_height = None self.depth_image = None self.marker_image = None self.display_image = None self.keystroke = None self.keep_marker_history = False self.cX=0 self.cY=0 cv.NamedWindow("Parameters", 0) cv.MoveWindow("Parameters", 700, 325) # Create the slider controls for saturation, value and threshold cv.CreateTrackbar("Min H", "Parameters", self.hmin, 255, self.set_hmin) cv.CreateTrackbar("Max H", "Parameters", self.hmax, 255, self.set_hmax) cv.CreateTrackbar("Min S", "Parameters", self.smin, 255, self.set_smin) cv.CreateTrackbar("Max S", "Parameters", self.smax, 255, self.set_smax) cv.CreateTrackbar("Min Value", "Parameters", self.vmin, 255, self.set_vmin) cv.CreateTrackbar("Max Value", "Parameters", self.vmax, 255, self.set_vmax) # Create the main display window self.cv_window_name = self.node_name cv.NamedWindow(self.cv_window_name, cv.CV_WINDOW_NORMAL) cv.NamedWindow("reality", cv.CV_WINDOW_NORMAL) cv.NamedWindow("depth", cv.CV_WINDOW_NORMAL) # Create the cv_bridge object self.bridge = CvBridge() # Subscribe to the image and depth topics and set the appropriate callbacks # The image topic names can be remapped in the appropriate launch file self.image_sub = rospy.Subscriber("input_rgb_image", Image, self.image_callback, queue_size=1) self.depth_sub = rospy.Subscriber("input_depth_image", Image, self.depth_callback, queue_size=1)
temp1 = cv.CloneImage(frame) cv.Rectangle(temp1, point1, point2, color, 1) cv.PutText(temp1, "Place in box", (430, 240), font, color) cv.PutText(temp1, "then hit q", (430, 260), font, color) #taking snapshot after q is pressed if cv.WaitKey(10) == 113: flag = 1 cv.SetImageROI(temp1, (300, 200, 100, 100)) template = cv.CloneImage(temp1) cv.ResetImageROI(temp1) cv.DestroyWindow("Image") if flag == 0: cv.NamedWindow("Image", 1) cv.MoveWindow("Image", 300, 0) cv.ShowImage("Image", temp1) continue W, H = cv.GetSize(frame) w, h = cv.GetSize(template) width = W - w + 1 height = H - h + 1 result = cv.CreateImage((width, height), 32, 1) #matching the template by searching for the given region in the image cv.MatchTemplate(frame, template, result, cv.CV_TM_SQDIFF_NORMED) (min_x, max_y, minloc, maxloc) = cv.MinMaxLoc(result) (x, y) = minloc X1 = (x * 1366) / 640 Y1 = (y * 768) / 480
def __init__(self): rospy.init_node('video2ros', anonymous=False) rospy.on_shutdown(self.cleanup) """ Define the input (path to video file) as a ROS parameter so it can be defined in a launch file or on the command line """ self.input = rospy.get_param("~input", "") """ Define the image publisher with generic topic name "output" so that it can be remapped in the launch file. """ image_pub = rospy.Publisher("output", Image) # The target frames per second for the video self.fps = rospy.get_param("~fps", 25) # Do we restart the video when the end is reached? self.loop = rospy.get_param("~loop", False) # Start the video paused? self.start_paused = rospy.get_param("~start_paused", False) # Show text feedback by default? self.show_text = rospy.get_param("~show_text", True) # Resize the original video? self.resize_video = rospy.get_param("~resize_video", False) # If self.resize_video is True, set the desired width and height here self.resize_width = rospy.get_param("~resize_width", 0) self.resize_height = rospy.get_param("~resize_height", 0) # Initialize a few variables self.paused = self.start_paused self.loop_video = True self.keystroke = None self.restart = False self.last_frame = None # Initialize the text font font_face = cv2.FONT_HERSHEY_SIMPLEX font_scale = 0.5 # Define the capture object as pointing to the input file self.capture = cv2.VideoCapture(self.input) # Get the original frames per second fps = self.capture.get(cv.CV_CAP_PROP_FPS) # Get the original frame size self.frame_size = (self.capture.get(cv.CV_CAP_PROP_FRAME_HEIGHT), self.capture.get(cv.CV_CAP_PROP_FRAME_WIDTH)) # Check that we actually have a valid video source if fps == 0.0: print "Video source", self.input, "not found!" return None # Bring the fps up to the specified rate try: fps = int(fps * self.fps / fps) except: fps = self.fps # Create the display window cv.NamedWindow("Video Playback", True) # autosize the display cv.MoveWindow("Video Playback", 375, 25) # Create the CvBridge object bridge = CvBridge() # Enter the main processing loop while not rospy.is_shutdown(): # Get the next frame from the video frame = self.get_frame() # Convert the frame to ROS format try: image_pub.publish(bridge.cv_to_imgmsg(cv.fromarray(frame), "bgr8")) except CvBridgeError, e: print e # Create a copy of the frame for displaying the text display_image = frame.copy() if self.show_text: cv2.putText(display_image, "FPS: " + str(self.fps), (10, 20), font_face, font_scale, cv.RGB(255, 255, 0)) cv2.putText(display_image, "Keyboard commands:", (20, int(self.frame_size[0] * 0.6)), font_face, font_scale, cv.RGB(255, 255, 0)) cv2.putText(display_image, " ", (20, int(self.frame_size[0] * 0.65)), font_face, font_scale, cv.RGB(255, 255, 0)) cv2.putText(display_image, "space - toggle pause/play", (20, int(self.frame_size[0] * 0.72)), font_face, font_scale, cv.RGB(255, 255, 0)) cv2.putText(display_image, " r - restart video from beginning", (20, int(self.frame_size[0] * 0.79)), font_face, font_scale, cv.RGB(255, 255, 0)) cv2.putText(display_image, " t - hide/show this text", (20, int(self.frame_size[0] * 0.86)), font_face, font_scale, cv.RGB(255, 255, 0)) cv2.putText(display_image, " q - quit the program", (20, int(self.frame_size[0] * 0.93)), font_face, font_scale, cv.RGB(255, 255, 0)) # Merge the original image and the display image (text overlay) display_image = cv2.bitwise_or(frame, display_image) # Now display the image. cv2.imshow("Video Playback", display_image) """ Handle keyboard events """ self.keystroke = cv.WaitKey(1000 / fps) """ Process any keyboard commands """ if 32 <= self.keystroke and self.keystroke < 128: cc = chr(self.keystroke).lower() if cc == 'q': """ user has press the q key, so exit """ rospy.signal_shutdown("User hit q key to quit.") elif cc == ' ': """ Pause or continue the video """ self.paused = not self.paused elif cc == 'r': """ Restart the video from the beginning """ self.restart = True elif cc == 't': """ Toggle display of text help message """ self.show_text = not self.show_text
def setup_camera_window(): cv.NamedWindow('camera', cv.CV_WINDOW_AUTOSIZE) cv.MoveWindow('camera', 10, 10)