class Robot(object): def __init__(self): self.mouse = PyMouse() self.keyboard = PyKeyboard() self.przyciskPSP2klawiatura = {'up': 'w', 'right': 'd', 'down': 's', 'left': 'a', 'triangle': self.keyboard.enter_key, 'circle': 'f', 'cross': 'g', 'square': 'h', 'l': self.keyboard.control_r_key, 'r': self.keyboard.shift_r_key, 'start': 'k', 'select': 'l'} def reaguj(self, x, y, przyciskPSP2Stan): self.reaguj_mysz(x, y) self.reaguj_klawiatura(przyciskPSP2Stan) def reaguj_mysz(self, x, y): max_predkosc_kursora = 0.00000000000000000000000000000000000000000000000000001 x += int((x / float(128)) * max_predkosc_kursora + self.mouse.position()[0]) y += int((y / float(128)) * max_predkosc_kursora + self.mouse.position()[1]) x, y = min(self.mouse.screen_size()[0], x), min( self.mouse.screen_size()[1], y) x, y = max(0, x), max(0, y) self.mouse.move(x, y) def reaguj_klawiatura(self, przyciskPSP2Stan): for przycisk_psp, czyWcisniety in przyciskPSP2Stan.iteritems(): przycisk_klawiaturowy = self.przyciskPSP2klawiatura[przycisk_psp] if czyWcisniety == '1': if przycisk_klawiaturowy == 'g': self.mouse.click(*self.mouse.position()) break self.keyboard.press_key(przycisk_klawiaturowy) else: self.keyboard.release_key(przycisk_klawiaturowy)
def show_mouse_position(): # import the module from pymouse import PyMouse m = PyMouse() m.move(200, 200) # click works about the same, except for int button possible values are 1: left, 2: right, 3: middle m.click(500, 300, 1) # get the screen size m.screen_size() # (1024, 768) # get the mouse position m.position()
def netflix_continue(): m = PyMouse() x, y = m.screen_size() m.click(x/2, y/2-60) time.sleep(0.33) m.move(x/2, 0) return ""
class MenuOjoData: DEGREEE_PATTERN = r"(?P<degree_data>[+-]\d{2})" def __init__(self): self.driver = PantojoBluetoothReceiver() self.pipes = [PantojoRealDataPipe()] self.mouse = PyMouse() (self.x_max, self.y_max) = self.mouse.screen_size() self.degree = re.compile(self.DEGREEE_PATTERN, re.VERBOSE) def open(self): self.driver.open() def recv(self): data = self.driver.recv() for pipe in self.pipes: data = pipe.apply(data) matched = self.degree.match(data) if matched: valor = int(data) (x, y) = self.mouse.position() if (valor != 0): #asumo que se mueve de a 15 mov = (self.x_max / 7) * (valor / 15) + x self.mouse.move(mov, y) else: self.mouse.move(self.x_max / 2, y) return data def close(self): self.driver.close()
def main(): mouse = PyMouse() # wm = cwiid.Wiimote("00:25:A0:CE:3B:6D") wm = cwiid.Wiimote() wm.rpt_mode = cwiid.RPT_BTN | cwiid.RPT_IR X, x = calibrate(wm) trans = getTransMatrix(x, X) screen = mouse.screen_size() lastTime = time.time() o = None state = NEUTRAL print("battery: %f%%" % (float(wm.state["battery"]) / float(cwiid.BATTERY_MAX) * 100.0)) window = pygame.display.set_mode((200, 150)) while True: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit(0) pos = getWiiPointNonBlock(wm) if pos != None: ipt = numpy.matrix([[pos.x], [pos.y], [1]]) optMat = trans.I * ipt o = Point(optMat[0] / optMat[2], optMat[1] / optMat[2]) if o.x < 0: o.x = 0 elif o.x >= screen[0]: o.x = screen[0] - 1 if o.y < 0: o.y = 0 elif o.y >= screen[1]: o.y = screen[1] - 1 if state == NEUTRAL: state = FIRST_INPUT lastTime = time.time() elif state == FIRST_INPUT: if time.time() - FIRST_INPUT_TO_PRESSED > lastTime: mouse.press(o.x, o.y) state = PRESSED elif state == PRESSED: mouse.move(o.x, o.y) if state == FIRST_INPUT and pos == None and time.time() - FIRST_INPUT_TO_PRESSED < lastTime: mouse.click(o.x, o.y) time.sleep(0.2) state = NEUTRAL if state == PRESSED and pos == None and time.time() - 1 > lastTime: mouse.release(o.x, o.y) state = NEUTRAL
class Mouse: def __init__(self): import autopy from pymouse import PyMouse self.m1 = autopy.mouse self.loc = [self.m1.get_pos()[0],self.m1.get_pos()[1]] self.m = PyMouse() self.m.move(self.loc[0], self.loc[1]) def move(self,direction): #Move mouse self.loc[0] += direction[0] self.loc[1] += direction[1] #FIXME: Support multiple displays #Check horizontal bounds self.loc[0] = min(self.loc[0],3600)#self.m.screen_size()[0]) self.loc[0] = max(self.loc[0],0) #Check vertical bounds self.loc[1] = min(self.loc[1],self.m.screen_size()[1]) self.loc[1] = max(self.loc[1],0) self.m.move(int(self.loc[0]), int(self.loc[1])) def click(self,button): self.m1.click(button)
def test_size(self): for size in screen_sizes: try: disp = Display(visible=VISIBLE, size=size).start() mouse = PyMouse() eq_(size, mouse.screen_size()) finally: disp.stop()
class HostDeviceClass: def __init__(self): self.m = PyMouse() self.screen = HelperClasses.ScreenClass(self.m.screen_size()[0], self.m.screen_size()[1]) self.cursor = HelperClasses.CursorClass(self.screen.width/2, self.screen.height/2) def moveCursorToCenter(self): self.cursor = HelperClasses.CursorClass(self.screen.width/2, self.screen.height/2) print "Updated Cursor Position to center of screen (" + str(self.cursor.x) + ", " + str(self.cursor.y) + ")." self.moveCursor() def moveCursor(self): self.m.move(self.cursor.x, self.cursor.y) def mousePress(self): print "PRESS" self.m.press(self.cursor.x, self.cursor.y) def mouseRelease(self): print "RELEASE" self.m.release(self.cursor.x, self.cursor.y) def displaceCursor(self, disp): # update cursor new_x = self.cursor.x + disp.x new_y = self.cursor.y + disp.y # screen limits if new_x > self.screen.width: new_x = self.screen.width if new_x < 0: new_x = 0 if new_y > self.screen.height: new_y = self.screen.height if new_y < 0: new_y = 0 actualMovement = HelperClasses.CursorClass(self.cursor.x - new_x, self.cursor.y - new_y) self.cursor.x = new_x self.cursor.y = new_y self.moveCursor() return actualMovement
def main(): mouse = PyMouse() # wm = cwiid.Wiimote("00:25:A0:CE:3B:6D") wm = cwiid.Wiimote() wm.rpt_mode = cwiid.RPT_BTN | cwiid.RPT_IR X,x = calibrate(wm) trans = getTransMatrix(x, X) screen = mouse.screen_size() lastTime = time.time() o = None points = [] print('battery: %f%%' % (float(wm.state['battery']) / float(cwiid.BATTERY_MAX) * 100.0)) window = pygame.display.set_mode((200, 150)) while True: for event in pygame.event.get(): if (event.type == pygame.QUIT): sys.exit(0) while (time.time() < lastTime + 0.01): pos = getWiiPointNonBlock(wm) if (pos != None): points.append(pos) print(len(points)) if (len(points) > 0): pos = avPoints(points) ipt = numpy.matrix([[pos.x], [pos.y], [1]]) optMat = trans.I * ipt o = Point(optMat[0] / optMat[2], optMat[1] / optMat[2]) if (o.x < 0): o.x = 0 elif (o.x >= screen[0]): o.x = screen[0] - 1 if (o.y < 0): o.y = 0 elif (o.y >= screen[1]): o.y = screen[1] - 1 mouse.move(o.x, o.y) if (wm.state['buttons'] & cwiid.BTN_A): mouse.click(o.x, o.y) lastTime = time.time() points = []
class HostDeviceClass: def __init__(self): self.m = PyMouse() self.screen = HelperClasses.ScreenClass(self.m.screen_size()[0], self.m.screen_size()[1]) self.cursor = HelperClasses.CursorClass(self.screen.width / 2, self.screen.height / 2) def moveCursorToCenter(self): self.cursor = HelperClasses.CursorClass(self.screen.width / 2, self.screen.height / 2) print "Updated Cursor Position to center of screen (" + str( self.cursor.x) + ", " + str(self.cursor.y) + ")." self.moveCursor() def moveCursor(self): self.m.move(self.cursor.x, self.cursor.y) def mousePress(self): print "PRESS" self.m.press(self.cursor.x, self.cursor.y) def mouseRelease(self): print "RELEASE" self.m.release(self.cursor.x, self.cursor.y) def displaceCursor(self, disp): # update cursor new_x = self.cursor.x + disp.x new_y = self.cursor.y + disp.y # screen limits if new_x > self.screen.width: new_x = self.screen.width if new_x < 0: new_x = 0 if new_y > self.screen.height: new_y = self.screen.height if new_y < 0: new_y = 0 actualMovement = HelperClasses.CursorClass(self.cursor.x - new_x, self.cursor.y - new_y) self.cursor.x = new_x self.cursor.y = new_y self.moveCursor() return actualMovement
def upload_file(self, file): # 定位上传按钮 self.click(self.salon_banner_loc) k = PyKeyboard() m = PyMouse() # 模拟快捷键Command+Shift+G k.press_keys(['Command', 'Shift', 'G']) # 输入文件路径 x_dim, y_dim = m.screen_size() m.click(x_dim // 2, y_dim // 2, 1) k.type_string(file) # 前往文件 k.press_keys(['Return']) # 点击确定进行上传 k.press_keys(['Return'])
def fuck_with_arduino(port): print("F*****g with the arduino") ser = serial.Serial(port=port, baudrate=9600, bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, timeout=1, xonxoff=False, rtscts=False, dsrdtr=False, writeTimeout=2) mouse = PyMouse() keyboard = PyKeyboard() screen_size = mouse.screen_size() screen_width = (screen_size[0]) / 244 screen_height = (screen_size[1]) / 244 assert (ser.isOpen()) while True: ray = ser.readline() if (len(ray) > 2 and ray[0] == 109): mouse.move(int((ray[1] - 11) * screen_width), int((ray[2] - 11) * screen_height)) elif (len(ray) > 1 and ray[0] == ord('C')): print("mouse_down: " + str(ray[1])) pos = mouse.position() mouse.press(pos[0], pos[1], ray[1]) elif (len(ray) > 1 and ray[0] == ord('U')): print("mouse_up: " + str(ray[1])) pos = mouse.position() mouse.release(pos[0], pos[1], ray[1]) elif (len(ray) > 0 and ray[0] == ord('p')): print("PASTE M**********R") ray = ray.decode() if (len(ray) > 0): ray = ray[1:ray.find("\n")] clipboard_copy(ray) keyboard.type_string(ray) elif (len(ray) > 0 and ray[0] == ord('c')): keyboard.press_keys([ "Command" if platform == "darwin" else keyboard.control_key, "c" ]) sleep(1) replyCopy(ser) elif (len(ray) > 1 and ray[0] == ord('s')): print("Status: <" + str(ray[1]))
def get_screen_size(): # returns [width, height] screen_size = None if system() == "Darwin": screen_size = sp.check_output(["./mac_os_helpers/get_screen_size"]) screen_size = screen_size.split(",") screen_size = [float(screen_size[0]), float(screen_size[1])] else: try: from pymouse import PyMouse m = PyMouse() screen_size = m.screen_size() except ImportError as e: print "Error: %s" % (e) return screen_size
def get_screen_size(): # returns [width, height] screen_size = None if system() == "Darwin": screen_size = sp.check_output(["./mac_os_helpers/get_screen_size"]) screen_size = screen_size.split(",") screen_size = [float(screen_size[0]),float(screen_size[1])] else: try: from pymouse import PyMouse m = PyMouse() screen_size = m.screen_size() except ImportError as e: print "Error: %s" %(e) return screen_size
class MouseController: def __init__(self): self.mouse = PyMouse() def set_mouse_position(self,x,y): self.mouse.move(x,y) def get_mouse_position(self): return self.mouse.position() def get_screen_size(self): return self.mouse.screen_size() #x,y, button possible values are 1: left, 2: middle, 3: right def click_at_location(self,x,y,button_id): self.mouse.click(x,y,button_id)
def control_mouse(): m = PyMouse() screen_width, screen_height = m.screen_size() cap = cv2.VideoCapture(0) mouse_img = cv2.imread('key.jpg') # plt.imshow(mouse_img) # surf = cv2.SURF(400) # kp1, des1 = surf.detectAndCompute(mouse_img, None) # print 'Starting with %d kp' % len(kp1) red = cv2.cv.CV_RGB(255,0,0) while True: flag, frame = cap.read() # kp2, des2 = surf.detectAndCompute(frame, None) # print 'Got %d kp' % len(kp2) # bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True) # matches = bf.match(des1, des2) # pt_list = [] # for match in sorted(matches, key=lambda x:x.distance)[:10]: # pt_list.append(kp2[match.trainIdx].pt) # pt = tuple(map(int, kp2[match.trainIdx].pt)) # cv2.circle(frame, pt, 5, red) # median_x = int(np.median([x for x,y in pt_list])) # median_y = int(np.median([y for x,y in pt_list])) # m.move(median_x, median_y) frame_width, frame_height, depth = frame.shape match = cv2.matchTemplate(mouse_img, frame, cv2.cv.CV_TM_CCORR) smoothed = uniform_filter(match, size=5) print 'S:', smoothed.shape print 'F:', frame.shape # new_frame = match.resize((frame_width, frame_height)) max_index = np.argmin(match) max_index_row = max_index / frame_width max_index_col = max_index % frame_width red = cv2.cv.CV_RGB(255,0,0) cv2.circle(frame, (max_index_row, max_index_col), 50, red) # cv2.imshow('frame', smoothed) plt.imshow(match) plt.show() if cv2.waitKey(1) & 0xFF == ord('q'): break
class MouseWand(Wand): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.left_color = "#2185d0" self.right_color = "#f2711c" self.left = False self.pressed_left = False def post_connect(self): print("Move the wand to move the mouse") print("Tilt the want to the left (blue light) to left click") print("Tilt the want to the right (orange light) to right click") print( "Tilt the wand left, hold the button, tilt the wand to the right, and release the button to disconnect" ) # Create a mouse and get the screen dimensions self._m = PyMouse() self.x_dim, self.y_dim = self._m.screen_size() self.set_led(self.left_color) self.subscribe_button() self.subscribe_position() def on_position(self, x, y, pitch, roll): # Do some magic to get an adjusted x and y position x_pos = self.x_dim * ((x * 4 + 1000) / 2000) y_pos = self.y_dim * (1.0 - (y * 4 + 1000) / 2000) # Move the mouse self._m.move(int(round(x_pos)), int(round(y_pos))) # Change left mouse button status and set LED when necessary if roll > 0 and self.left: self.left = False self.set_led(self.right_color) elif roll < 0 and not self.left: self.left = True self.set_led(self.left_color) def on_button(self, pressed): x_pos, y_pos = self._m.position() if pressed: self._m.press(x_pos, y_pos, 1 if self.left else 2) self.pressed_left = self.left else: self._m.release(x_pos, y_pos, 1 if self.left else 2) if self.pressed_left and not self.left: self.disconnect()
def runScript(delay, SCRIPT_PATH, SCRIPT_NAME): screen = wnck.screen_get(0) #screen = wnck.screen_get_default() while gtk.events_pending(): gtk.main_iteration() windowTitle = re.compile('.*Board.*') for window in screen.get_windows(): if windowTitle.match(window.get_name()): window.activate(int(time.time())) window.maximize() #MOUSE CLICK TO ACTUALLY FOCUS EAGLE BOARD m = PyMouse() x, y = m.screen_size() #m.click(x/4, y/4, 1) #KEYBOARD INPUT k = PyKeyboard() caps_flag = 0 if int(commands.getoutput('xset q | grep LED')[65]) % 2: k.tap_key(k.caps_lock_key) caps_flag = 1 #BRING UP ALT-FILE MENU k.press_key(k.alt_key) k.type_string('f') k.release_key(k.alt_key) #PRESS T TO RUN SCRIPT FROM ALT-FILE MENUs k.type_string('t') time.sleep(delay) #TYPE IN SCRIPT NAME TO DIALOG BOX k.type_string(SCRIPT_PATH + SCRIPT_NAME) time.sleep(delay) time.sleep(delay) k.tap_key(k.enter_key) if caps_flag: k.tap_key(k.caps_lock_key)
class PointerNode(Node): nodeName = "Pointer" def __init__(self, name): terminals = { 'irXIn': dict(io='in'), 'irYIn': dict(io='in'), 'bPressed': dict(io='in'), 'aPressed': dict(io='in'), 'bRel': dict(io='in'), } self.mouse = PyMouse() self.screenSize = self.mouse.screen_size() self.dragging = False Node.__init__(self, name, terminals=terminals) def process(self, **kwds): self.irX = kwds['irXIn'] self.irY = kwds['irYIn'] self.isBPressed = kwds['bPressed'] self.isAPressed = kwds['aPressed'] self.isBReleased = kwds['bRel'] # check if B button is pressed and ir data is not zero if self.isBPressed and self.irX != 0 and self.irY != 0: # recalculate the x and y pos of the mouse depending on the ir data and screen size xScreen = self.screenSize[0] - int((self.screenSize[0] / 1024) * self.irX) yScreen = int((self.screenSize[1] / 760) * self.irY) # check if x and y data is valid and move mouse to pos if xScreen <= self.screenSize[0] and xScreen >= 0 and yScreen <= self.screenSize[1] and yScreen >= 0: self.mouse.move(xScreen, yScreen) # when b is released and object is dragged, object is released if self.isBReleased and self.dragging: self.mouse.click(self.mouse.position()[0], self.mouse.position()[1]) self.dragging = False # when b is not pressed and a is pressed, do a single click if self.isAPressed and not self.isBPressed: self.mouse.click(self.mouse.position()[0], self.mouse.position()[1]) self.dragging = False # when b and a are pressed, do drag elif self.isAPressed and self.isBPressed: self.mouse.press(self.mouse.position()[0], self.mouse.position()[1]) self.dragging = True
def upload_file(self, file): self.click(self.salon_banner_loc) k = PyKeyboard() m = PyMouse() filepath = '/' k.press_keys(['Command', 'Shift', 'G']) x_dim, y_dim = m.screen_size() m.click(x_dim // 2, y_dim // 2, 1) # 复制文件路径开头的斜杠/ pyperclip.copy(filepath) # 粘贴斜杠/ k.press_keys(['Command', 'V']) # 输入文件全路径进去 k.type_string(file) k.press_key('Return') time.sleep(2) k.press_key('Return')
class ScreenShot(Thread): # CONFIGURATION SCALE_RATIO_X = 1.4 SCALE_RATIO_Y = 2 MAX_SCREENSHOT_COUNT = 5 # DELAY IN SECONDS DELAY_BETWEEN_SCREENSHOTS = 2.0 slide_counter = 0 def __init__(self, event): Thread.__init__(self) # set wx for screenshot self.screen = wx.ScreenDC() self.size = self.screen.GetSize() self.bmp = wx.EmptyBitmap(self.size[0], self.size[1]) # set mouse click settings self.stopped = event self.mouse = PyMouse() self.width, self.height = self.mouse.screen_size() self.set_coordinates() def set_coordinates(self): self.x = self.width / self.SCALE_RATIO_X self.y = self.height / self.SCALE_RATIO_Y def perform_click(self): self.mouse.click(self.x, self.y) def take_screenshot(self): mem = wx.MemoryDC(self.bmp) mem.Blit(0, 0, self.size[0], self.size[1], self.screen, 0, 0) del mem self.bmp.SaveFile('screenshot{0}.png'.format(self.slide_counter), wx.BITMAP_TYPE_PNG) def run(self): while not self.stopped.wait(self.DELAY_BETWEEN_SCREENSHOTS): self.slide_counter += 1 self.perform_click() self.take_screenshot() if self.slide_counter > self.MAX_SCREENSHOT_COUNT: self.stopped.set()
def scroll_screen(self, element, vertical=-10, ele=None, zoom=1): """ :param element: 目标元素,即想要看到的元素 :param vertical: 每一步垂直滚动的距离, +向上,-向下 """ m = PyMouse() while not element.is_displayed(): x_dim, y_dim = m.screen_size() sleep(3) if ele is None: # m.move(x_dim // 2, y_dim // 2) pass else: m.move( ele.location_once_scrolled_into_view.get('x') * zoom, ele.location_once_scrolled_into_view.get('y') * zoom) m.scroll(vertical=vertical) sleep(3)
class Mouse_trace: """Mouse tracing Class. It uses vispy to visualization.""" def __init__(self, color = (1.0, 1.0, 1.0, 1.0)): self.mouse = PyMouse() self.pos = np.asarray([0, 0, 0]) self.color = color self.rad = 20.0 size = self.mouse.screen_size() boundaries = np.asarray([[0, size[0]], [0, size[1]], [0, 1]]) print(boundaries) self.sizexyz = [None] * 3 self.tail_steps = 200 self.set_bound(boundaries) self.visual = [None] def set_bound(self, boundaries): """Updates the boundaries.""" self.bound = boundaries self.sizexyz = np.abs(boundaries[:,1] - boundaries[:,0]) def step(self, time_step): """Calculate the new position and speed.""" mpos = self.mouse.position() self.pos = np.asarray([mpos[0], self.bound[1,1] - mpos[1], 0]) self.update_visual() def init_visual(self, view): """Initialize the object visual.""" self.trace = np.repeat(self.pos, self.tail_steps).reshape((3,self.tail_steps)).T pos = np.concatenate([sphere_pt * self.rad + self.pos, self.trace]) self.visual = Line(pos = pos, color=self.color) view.add(self.visual) def update_visual(self): """Updates the object visual.""" self.trace[1:] = self.trace[0:-1] self.trace[0] = self.pos pos = np.concatenate([sphere_pt * self.rad + self.pos, self.trace]) self.visual.set_data(pos = pos) def shake(self): """Inverts the z position and gives the ball a random velocity.""" pass
class Cursor(object): def __init__(self, init_pos): # init_pos: type:tuple, set `False` to skip initing position. self.c = PyMouse() if init_pos != False and len(init_pos) == 2: self.move_to(init_pos) def move_to(self, pos): self.c.move(pos[0], pos[1]) def get_pos(self): return self.c.position() def click(self, pos): # bak_x, bak_y = self.c.position() self.c.click(pos[0], pos[1], 1) # self.c.move(bak_x, bak_y) def get_screen_wh(self): return self.c.screen_size()
def mouseControl(): """ Control the mouse using glove accelerometer """ m = PyMouse() x_dim, y_dim = m.screen_size() m.move(x_dim / 2, y_dim / 2) while True: x_pos = (x_dim / 2) + int(-share_var.yaw * x_dim / 90.0) y_pos = (y_dim / 2) + int(-share_var.pitch * y_dim / 90.0) # if (x_pos < 0): x_pos = 0 # if (x_pos > x_dim): x_pos = x_dim # if (y_pos < 0): y_pos = 0 # if (y_pos > y_dim): y_pos = y_dim m.move(x_pos, y_pos) if share_var.flexIndexFinger > 45: m.click(x_pos, y_pos)
class Sim: def __init__(self): self.m = PyMouse() self.k = PyKeyboard() def click(self): x_dim, y_dim = self.m.screen_size() self.m.click(int(x_dim / 2), int(y_dim / 2), 1) def pressLeft(self): self.tap(self.k.left_key) return "left" def pressRight(self): self.tap(self.k.right_key) return "right" def tap(self, key): self.k.tap_key(key) return key
def mouseControl(): """ Control the mouse using glove accelerometer """ m = PyMouse() x_dim,y_dim = m.screen_size() m.move(x_dim/2,y_dim/2) while True: x_pos = (x_dim/2) + int(-share_var.yaw*x_dim/90.0) y_pos = (y_dim/2) + int(-share_var.pitch*y_dim/90.0) # if (x_pos < 0): x_pos = 0 # if (x_pos > x_dim): x_pos = x_dim # if (y_pos < 0): y_pos = 0 # if (y_pos > y_dim): y_pos = y_dim m.move(x_pos, y_pos) if share_var.flexIndexFinger > 45: m.click(x_pos,y_pos)
def runScript(delay, SCRIPT_NAME): #screen = wnck.screen_get_default() screen = wnck.screen_get(0) while gtk.events_pending(): gtk.main_iteration() windowTitle = re.compile('.*Board.*') for window in screen.get_windows(): if windowTitle.match(window.get_name()): window.activate(int(time.time())) window.maximize() #MOUSE CLICK TO ACTUALLY FOCUS EAGLE BOARD m = PyMouse() x, y = m.screen_size() #m.click(x/4, y/4, 1) #KEYBOARD INPUT k = PyKeyboard() #BRING UP ALT-FILE MENU k.press_key(k.alt_key) k.type_string('f') k.release_key(k.alt_key) #PRESS T TO RUN SCRIPT FROM ALT-FILE MENU k.type_string('t') time.sleep(delay) #TYPE IN SCRIPT NAME TO DIALOG BOX k.type_string('/home/anton/Documents/st/st-py/' + SCRIPT_NAME) time.sleep(delay) time.sleep(delay) k.tap_key(k.enter_key)
def place_goal(self): w = WindowMgr() w.find_window_wildcard(".*Blocks Environment for AirSim Blocks Environment for AirSim*") #w.find_window_wildcard(".*Unreal Engine*") m = PyMouse() k = PyKeyboard() w.set_foreground() x_dim, y_dim = m.screen_size() #m.click(x_dim/2, y_dim/2, 1) k.type_string('q') print("place view point") time.sleep(1) file = open(r'''C:\Users\zeyua\Source\Repos\AirSim\Unreal\Environments\Blocks\Saved\StagedBuilds\WindowsNoEditor\Blocks\Spawn_Location.txt''',"r") des_string = file.readline() file.close() array = des_string.replace("="," ").split() print(array) self.des_x = float(array[1]) / 100 + 2 self.des_y = float(array[3]) / 100 + 2 self.des_z = float(array[5]) / (-100) + 0.6 print("destination: x,y,z =",self.des_x,self.des_y,self.des_z)
def set_abm_params(start_iter, sample_rates): """Set the parameters for the sandag_abm. Parameters ---------- start_iter : int The iteration to start the process from. sample_rates : str or None The sample rates for the abm in string form. """ mouse = PyMouse() board = PyKeyboard() xdim, ydim = mouse.screen_size() mouse.click(int(round(xdim * 0.57083)), int(round(ydim * 0.04952))) sleep(2) board.press_keys([board.alt_key, 'd']) board.press_keys([board.alt_key, 'n']) board.type_string('Setup Scenario') board.tap_key(board.enter_key) sleep(2) board.tap_key(board.space_key) sleep(5) # Set database write to 'No' board.tap_key(board.tab_key, n=22) board.tap_key(board.space_key) if start_iter == 1: board.tap_key(board.tab_key, n=7) else: board.tap_key(board.tab_key, n=2 + start_iter) board.tap_key(board.space_key) board.tap_key(board.tab_key, n=5 - start_iter) if sample_rates: board.tap_key(board.backspace_key) board.type_string(sample_rates) board.tap_key(board.tab_key) board.tap_key(board.space_key) sleep(1)
class KM: """ 这里存放所有模拟鼠标、键盘事件 """ def __init__(self): self.m = PyMouse() self.k = PyKeyboard() def open_wifi(self): # 打开wifi,暂时在非锁屏转态下才可用 self.m.move(1600, 870) time.sleep(1) self.m.click(1500, 860) time.sleep(1) self.m.click(1500, 850) time.sleep(1) self.k.tap_key(self.k.escape_key) return 'wifi已打开/关闭' def thunder_res(self): # 迅雷重启线程,注意迅雷X需要最大化,图标放最下角,第7个 self.m.move(1314, 863) time.sleep(1.6) self.m.click(1312, 850) time.sleep(1) self.m.click(1274, 817) time.sleep(3) self.m.click(336, 160) time.sleep(10) self.m.click(336, 160) time.sleep(2) self.m.click(1511, 25) time.sleep(0.5) screen_size = self.m.screen_size() self.m.move(int(screen_size[0] / 2), int(screen_size[1] / 2)) self.m.click(int(screen_size[0] / 2), int(screen_size[1] / 2)) return '迅雷已重启任务'
def on_frame(self,controller): m=PyMouse() x_dim, y_dim = m.screen_size() frame = controller.frame() print"Frame id: {}, timestamp: {}, hand: {}, fingers{}, tools: {}".format(frame.id, frame.timestamp,len(frame.hands),len(frame.fingers),len(frame.tools)) if not frame.hands.is_empty: hand=frame.hands[0] fingers=hand.fingers if not fingers.is_empty: print fingers[0].tip_position.x print fingers[0].tip_position.y m.move(((fingers[0].tip_position.x)+160)*x_dim/320,y_dim-((fingers[0].tip_position.y)-200)*y_dim/200) #alculate avg position avg_pos = Leap.Vector() for finger in fingers: avg_pos+=finger.tip_position avg_pos /= len(fingers) print "Hand has ablablabl" # can get radius and palm position print "Hand sphere radius: %f mm, palm position: %s" % (hand.sphere_radius, hand.palm_position) #can also get angles... for gesture in frame.gestures(): if controller.is_gesture_enabled(Leap.Gesture.TYPE_CIRCLE): if gesture.type == Leap.Gesture.TYPE_CIRCLE: circle = CircleGesture(gesture) m.click((circle.center.x+160)*x_dim/320,y_dim-(circle.center.y-200)*y_dim/200); if circle.center.x <0: #&& circle.center.y>230: print"upper left" else: print"right" controller.enable_gesture(Leap.Gesture.TYPE_CIRCLE,False) t=threading.Timer(2.0,timer_Disable,[controller]) t.start()
class KLMouse(object): ABSOLUTE = 1, RELATIVE = 2, def __init__(self): self.m = PyMouse() self.t = 0 self.lastX = 0 self.lastY = 0 self.mode = KLMouse.RELATIVE def mouse(self, evType, x, y, t): print evType, x, y, t if t > self.t: xDim, yDim = self.m.screen_size() if self.mode == KLMouse.ABSOLUTE: xNew = int(float(x) * xDim) yNew = int(float(y) * yDim) else: xNew = int(float(x) * xDim) yNew = int(float(y) * yDim) print xNew print yNew mX, mY = self.m.position() if evType == 'left' or evType == 'right': mX, mY = self.m.position(); self.m.click(mX, mY, {'left':1,'right':2}[evType]) else: if self.mode == KLMouse.ABSOLUTE: self.m.move(xNew, yNew) if self.mode == KLMouse.RELATIVE: self.m.move(mX + xNew, mY + yNew) self.t = t
def create_text(self, group, msg): self.click_btn_add_text() sleep(2) self.click_btn_select_group() sleep(2) # self.click_btn_text_groups() # sleep(1) self.scroll_screen(self.get_text_select_text_group(group)) sleep(1) self.click_text_select_text_group(group) sleep(1) self.click_text_select_text_group(group) sleep(1) self.click_btn_select_text_group(group) sleep(2) m = PyMouse() x_dim, y_dim = m.screen_size() m.click(x_dim // 2, y_dim // 2) sleep(1) self.sendkeys_input_text_msg(msg) sleep(2) self.click_btn_save() sleep(2) self.check_exist_in_page(msg)
def main(): try: from pymouse import PyMouseEvent class event(PyMouseEvent): def move(self, x, y): print("Mouse moved to", x, y) def click(self, x, y, button, press): if press: print("Mouse pressed at", x, y, "with button", button) else: print("Mouse released at", x, y, "with button", button) e = event() #e.capture = True e.start() except ImportError: print("Mouse events are not yet supported on your platform") m = PyMouse() try: size = m.screen_size() print("size: %s" % (str(size))) i_pos = m.position() print("current mouse postion is :%s " % (str(i_pos))) # print(i_pos) # pos = (random.randint(0, size[0]), random.randint(0, size[1])) except: print("error occur") try: e.stop() except: pass
KEY1=12345 ''' from pymouse import PyMouse import sysv_ipc as ipc import re,os,sys import time KEY1 = 12345 #shared memory KEY2 = 6789 #semaphore MAX_SAMPLES = 40 COUNT=45 DEBOUNCE = 30 shm = ipc.SharedMemory(KEY1) #implicitly attaches the shm sem = ipc.Semaphore(KEY2) m = PyMouse() size = m.screen_size() prev_x = 0 prev_y = 0 prev_xx=0 prev_yy=0 speed = 1 count=0 right_click_debounce = 0 left_click_debounce = 0 wheel_up_debounce = 0 wheel_down_debounce = 0 xx = range(MAX_SAMPLES) yy = range(MAX_SAMPLES)
import cv2 as cv import numpy as np from matplotlib import pyplot as plt import pdb import sys import os from pymouse import PyMouse m = PyMouse() from PIL import ImageGrab as ig #ig.grabclipboard() #img_rgb = ig.grabclipboard() img_rgb = ig.grab() print "image size:",img_rgb.width,img_rgb.height print m.screen_size() img_rgb = np.array(img_rgb) #img_rgb = cv.imread('1.png') img_gray = cv.cvtColor(img_rgb, cv.COLOR_BGR2GRAY) template = cv.imread(sys.argv[1],0) w, h = template.shape[::-1] methods = ['cv.TM_CCOEFF', 'cv.TM_CCOEFF_NORMED', 'cv.TM_CCORR', 'cv.TM_CCORR_NORMED', 'cv.TM_SQDIFF', 'cv.TM_SQDIFF_NORMED']
def main(drag=0.02, grav=1.5, bottom='bounce', left='bounce', right='bounce', top='bounce', allsides=None, maxspeed=40, framerate=50): """HeavyMouse - a python mouse mover\n example, for bouncy walls, no gravity and less speed: \n python heavymouse.py --drag .04 --grav 0 --allsides bounce --maxspeed 10 :param float drag: amount of drag. 0.0 to 1.0, default is 0.02 :param float grav: gravity, default is 1.5 :param str bottom: can be 'bounce', 'wrap' or 'stop' - default is bounce :param str left: can be 'bounce', 'wrap' or 'stop' - default is bounce :param str right: can be 'bounce', 'wrap' or 'stop' - default is bounce :param str top: can be 'bounce', 'wrap' or 'stop' - default is bounce :param str allsides: will override settings for each side - no default :param int maxspeed: prevent the mouse moving (much) faster than this each frame - default is 40 :param int framerate: frequency the program operates at - default is 50 """ friction = 1.0-drag sleeptime = 1000.0/framerate/1000.0 if allsides: top=right=left=bottom=allsides print((top, bottom)) m = PyMouse() mx, my = m.position() mx,my=float(mx), float(my) vx,vy=.0,.0 width,height = m.screen_size() print('Press Ctrl-C to quit.') try: while True: #get current position x, y = m.position() x,y=float(x), float(y) #alter vel by user input vx += float(x-mx)-vx+.5 vy += float(y-my)-vy+.5 #drag vx*=friction vy*=friction #gravity vy+=grav vel = (math.sqrt(vx**2+vy**2)) if vel > maxspeed: vx*=.7 vy*=.7 #update current and previous position mx=x my=y x+=vx y+=vy #wrap or bounce at screen edges if x < 0: if left == 'wrap': x+=width mx+=width elif left == 'bounce': x-=vx*2 xy=-vx else: #stop x=0 if y < 0: if top == 'wrap': y+=height my+=height elif top == 'bounce': y-=vy*2 vy=-vy else: #stop y=0 if x > width: if right == 'wrap': x-=width mx-=width elif right == 'bounce': x-=vx*2 xy=-vx else: #stop x=width if y > height: if bottom == 'wrap': y-=height my-=height elif bottom == 'bounce': y-=vy*2 vy=-vy else: #stop y=height #apply position to mouse m.move(int(x), int(y)) #debug output #positionStr = 'X: ' + str(x).rjust(4) + ' Y: ' + str(y).rjust(4) #print(positionStr) #print(vx, vy) #print('\b' * len(positionStr)) #sys.stdout.flush() time.sleep(sleeptime) except KeyboardInterrupt: print('\n')
def upload_pic(self, image_path, caption, c_flag=1): self.dummy_clicks( 'Upload', '//*[@id="react-root"]/section/nav[2]/div/div/div[2]/div/div/div[3]', 2, [1, 1]) ###### for windows ###### # handle file select # rand_Sleep(1, 2) # autokey.win_active("Open") # rand_Sleep(1, 2) # autokey.control_send("Open", "Edit1", image_path) # rand_Sleep(1, 2) # autokey.control_send("Open", "Edit1","{ENTER}") # rand_Sleep(1, 2) ###### for windows ends ###### ###### for linex ###### k = PyKeyboard() m = PyMouse() x_dim, y_dim = m.screen_size() for i in image_path: sleep(0.01) k.tap_key(i) rand_Sleep(1, 2) # to click open button m.click(x_dim - 60, 50, 1) # to click browser button ###### for linex ends ###### m.click(20, y_dim - 20, 1) rand_Sleep(2, 3) # image fit button try: img_fit_btn = self.driver.find_element_by_xpath( '//*[@id="react-root"]/section/div[2]/div[2]/div/div/div/button[1]' ) except Exception as e: pass else: img_fit_class = str( img_fit_btn.find_element_by_tag_name('span').get_attribute( 'class')) print(img_fit_class) if "Expand" in img_fit_class: self.dummy_clicks( 'Next', '//*[@id="react-root"]/section/div[2]/div[2]/div/div/div/button[1]' ) # next button self.dummy_clicks( 'Next', '//*[@id="react-root"]/section/div[1]/header/div/div[2]/button') if c_flag == 1: # add fake location self.dummy_clicks( 'Add Location', '//*[@id="react-root"]/section/div[2]/section[2]/button') options = 0 tr = 0 while options == 0 and tr < 5: tr += 1 self.dummy_writes( 'Location', '//*[@id="react-root"]/section/div[2]/input', self.faker.country()) options = len( self.driver.find_elements_by_xpath( '//*[@id="react-root"]/section/div[3]/div/div/button')) if options == 0: self.dummy_clicks( 'Go Back', '//*[@id="react-root"]/section/div[1]/header/div/div[1]/button' ) else: pick = random.randint(0, options) print('No. of Location picked is {}'.format(pick)) # pick a location rand_Sleep(3, 5) self.dummy_clicks( 'Pick Location', '//*[@id="react-root"]/section/div[3]/div/div/button[{}]'. format(pick)) # write caption rand_Sleep(1, 2) for line in caption: self.dummy_writes( 'Caption', '//*[@id="react-root"]/section/div[2]/section[1]/div[1]/textarea', line, 2, [0, 0]) rand_Sleep(1, 1) # share self.dummy_clicks( 'Share', '//*[@id="react-root"]/section/div[1]/header/div/div[2]/button') rand_Sleep(5, 10) self.close_extras()
def run(self): global running last_time = datetime.datetime.now() m=PyMouse() measure = str(datetime.datetime.now() - last_time).split(":", 1)[1].split(":", 1)[1] data = None X,Y,CX,CY,LX,LY,dirX,dirY=0,0,0,0,0,0,0,0 CXX,CYY,LXX,LYY=0,0,0,0 max_steps=120 XX = range(0) YY = range(0) screen_dim = m.screen_size() print "Screen Xdim = " + str(screen_dim[0]) print "Screen Ydim = " + str(screen_dim[1]) while running: if not reciever.empty(): data=reciever.get_nowait() reciever.task_done() last_time = datetime.datetime.now() if (len(XX)>2 or len(YY)>2) and float(measure)>0.2: print "timout..." print "measure = " + str(measure) print "len XX = " + str(len(XX)) if len(XX)>0:XX.pop(0) if len(YY)>0:YY.pop(0) if re.match("ROW", str(data)) is not None: CY = int(data.split("COL",1)[0].split("ROW",1)[1]) CX = int(data.split("ROW",1)[1].split("COL",1)[1]) data=None if CY is not None and CX is not None and float(measure)<0.1: print "\n" if (CX-LX)>0 and CX!=LX: XX.append(1) elif (CX-LX)<0 and CX!=LX: XX.append(-1) elif CX!=LX: XX.append(0) if (CY-LY)>0 and CY!=LY: YY.append(1) elif (CY-LY)<0 and CY!=LY: YY.append(-1) elif CY!=LY: YY.append(0) print "moving..." print "measure = " + str(measure) dirX=sum(XX)+(self.divider(1,LX)) dirY=sum(YY)+(self.divider(1,LY)) current_pos = m.position() print "len XX = " + str(len(XX)) m.move((current_pos[0]+(dirX*3)),current_pos[1]+(dirY*2)) if len(XX)>=5 or len(YY)>=5: if len(XX)>0:XX.pop(0) if len(YY)>0:YY.pop(0) print "len XX = " + str(len(XX)) last_time = datetime.datetime.now() LX=CX LY=CY CX=None CY=None time.sleep(0.0001) measure = str(datetime.datetime.now() - last_time).split(":", 1)[1].split(":", 1)[1]
class Bot(object): """Mouse and Keyboard robot class. Abbreviation table: - m: stands for mouse - k: stands for keyboard - dl: stands for delay - n: how many times you want to tap the key - i: usually for the ith function key, F1 ~ F12 Almost every method have an option keyword ``dl`` (dl stands for delay), there is ``dl`` seconds delay applied at begin. By default it is ``None``, means no delay applied. Keyboard Key Name Table (Case Insensitive):: # Main Keyboard Keys "ctrl": self.k.control_key, "l_ctrl": self.k.control_l_key, "r_ctrl": self.k.control_r_key, "alt": self.k.alt_key, "l_alt": self.k.alt_l_key, "r_alt": self.k.alt_r_key, "shift": self.k.shift_key, "l_shift": self.k.shift_l_key, "r_shift": self.k.shift_r_key, "tab": self.k.tab_key, "space": self.k.space, "enter": self.k.enter_key, "back": self.k.backspace_key, "backspace": self.k.backspace_key, # Side Keyboard Keys "home": self.k.home_key, "end": self.k.end_key, "page_up": self.k.page_up_key, "pageup": self.k.page_up_key, "page_down": self.k.page_down_key, "page_down": self.k.page_down_key, "insert": self.k.insert_key, "ins": self.k.insert_key, "delete": self.k.delete_key, "del": self.k.delete_key, "up": self.k.up_key, "down": self.k.down_key, "left": self.k.left_key, "right": self.k.right_key, # Function Keys "f1": F1 """ def __init__(self): self.m = PyMouse() self.k = PyKeyboard() self.dl = 0 self._key_mapper = { # Main Keyboard Keys "ctrl": self.k.control_key, "l_ctrl": self.k.control_l_key, "r_ctrl": self.k.control_r_key, "alt": self.k.alt_key, "l_alt": self.k.alt_l_key, "r_alt": self.k.alt_r_key, "shift": self.k.shift_key, "l_shift": self.k.shift_l_key, "r_shift": self.k.shift_r_key, "tab": self.k.tab_key, "space": self.k.space, "enter": self.k.enter_key, "back": self.k.backspace_key, "backspace": self.k.backspace_key, # Side Keyboard Keys "home": self.k.home_key, "end": self.k.end_key, "page_up": self.k.page_up_key, "pageup": self.k.page_up_key, "page_down": self.k.page_down_key, "page_down": self.k.page_down_key, "insert": self.k.insert_key, "ins": self.k.insert_key, "delete": self.k.delete_key, "del": self.k.delete_key, "up": self.k.up_key, "down": self.k.down_key, "left": self.k.left_key, "right": self.k.right_key, # f1 - f12 is the function key } for i in range(1, 1 + 12): self._key_mapper["f%s" % i] = self.k.function_keys[i] def _parse_key(self, name): name = str(name) if name in string.printable: return name elif name.lower() in self._key_mapper: return self._key_mapper[name.lower()] else: raise ValueError("%r is not a valid key name, use one of %s." % (name, list(self._key_mapper))) def delay(self, dl=0): """Delay for ``dl`` seconds. """ if dl is None: time.sleep(self.dl) elif dl < 0: sys.stderr.write( "delay cannot less than zero, this takes no effects.\n") else: time.sleep(dl) #--- Meta --- def get_screen_size(self): """Return screen's width and height in pixel. **中文文档** 返回屏幕的像素尺寸。 """ width, height = self.m.screen_size() return width, height def get_position(self): """Return the current coordinate of mouse. **中文文档** 返回鼠标所处的位置坐标。 """ x_axis, y_axis = self.m.position() return x_axis, y_axis #--- Mouse Macro --- def left_click(self, x, y, n=1, pre_dl=None, post_dl=None): """Left click at ``(x, y)`` on screen for ``n`` times. at begin. **中文文档** 在屏幕的 ``(x, y)`` 坐标处左键单击 ``n`` 次。 """ self.delay(pre_dl) self.m.click(x, y, 1, n) self.delay(post_dl) def right_click(self, x, y, n=1, pre_dl=None, post_dl=None): """Right click at ``(x, y)`` on screen for ``n`` times. at begin. **中文文档** 在屏幕的 ``(x, y)`` 坐标处右键单击 ``n`` 次。 """ self.delay(pre_dl) self.m.click(x, y, 2, n) self.delay(post_dl) def middle_click(self, x, y, n=1, pre_dl=None, post_dl=None): """Middle click at ``(x, y)`` on screen for ``n`` times. at begin. **中文文档** 在屏幕的 ``(x, y)`` 坐标处中键单击 ``n`` 次。 """ self.delay(pre_dl) self.m.click(x, y, 3, n) self.delay(post_dl) def scroll_up(self, n, pre_dl=None, post_dl=None): """Scroll up ``n`` times. **中文文档** 鼠标滚轮向上滚动n次。 """ self.delay(pre_dl) self.m.scroll(vertical=n) self.delay(post_dl) def scroll_down(self, n, pre_dl=None, post_dl=None): """Scroll down ``n`` times. **中文文档** 鼠标滚轮向下滚动n次。 """ self.delay(pre_dl) self.m.scroll(vertical=-n) self.delay(post_dl) def scroll_right(self, n, pre_dl=None, post_dl=None): """Scroll right ``n`` times. **中文文档** 鼠标滚轮向右滚动n次(如果可能的话)。 """ self.delay(pre_dl) self.m.scroll(horizontal=n) self.delay(post_dl) def scroll_left(self, n, pre_dl=None, post_dl=None): """Scroll left ``n`` times. **中文文档** 鼠标滚轮向左滚动n次(如果可能的话)。 """ self.delay(pre_dl) self.m.scroll(horizontal=-n) self.delay(post_dl) def move_to(self, x, y, pre_dl=None, post_dl=None): """Move mouse to (x, y) **中文文档** 移动鼠标到 (x, y) 的坐标处。 """ self.delay(pre_dl) self.m.move(x, y) self.delay(post_dl) def drag_and_release(self, start_x, start_y, end_x, end_y, pre_dl=None, post_dl=None): """Drag something from (start_x, start_y) to (end_x, endy) **中文文档** 从start的坐标处鼠标左键单击拖曳到end的坐标处 start, end是tuple. 格式是(x, y) """ self.delay(pre_dl) self.m.press(start_x, start_y, 1) self.m.drag(end_x, end_y) self.m.release(end_x, end_y, 1) self.delay(post_dl) #--- Keyboard Single Key --- def tap_key(self, key_name, n=1, interval=0, pre_dl=None, post_dl=None): """Tap a key on keyboard for ``n`` times, with ``interval`` seconds of interval. Key is declared by it's name Example:: bot.tap_key("a") bot.tap_key(1) bot.tap_key("up") bot.tap_key("space") bot.tap_key("enter") bot.tap_key("tab") **中文文档** 以 ``interval`` 中定义的频率按下某个按键 ``n`` 次。接受按键名作为输入。 """ key = self._parse_key(key_name) self.delay(pre_dl) self.k.tap_key(key, n, interval) self.delay(post_dl) def enter(self, n=1, interval=0, pre_dl=None, post_dl=None): """Press enter key n times. **中文文档** 按回车键/换行键 n 次。 """ self.delay(pre_dl) self.k.tap_key(self.k.enter_key, n, interval) self.delay(post_dl) def backspace(self, n=1, interval=0, pre_dl=None, post_dl=None): """Press backspace key n times. **中文文档** 按退格键 n 次。 """ self.delay(pre_dl) self.k.tap_key(self.k.backspace_key, n, interval) self.delay(post_dl) def space(self, n=1, interval=0, pre_dl=None, post_dl=None): """Press white space key n times. **中文文档** 按空格键 n 次。 """ self.delay(pre_dl) self.k.tap_key(self.k.space, n) self.delay(post_dl) def fn(self, i, n=1, interval=0, pre_dl=None, post_dl=None): """Press Fn key n times. **中文文档** 按 Fn 功能键 n 次。 """ self.delay(pre_dl) self.k.tap_key(self.k.function_keys[i], n, interval) self.delay(post_dl) def tab(self, n=1, interval=0, pre_dl=None, post_dl=None): """Tap ``tab`` key for ``n`` times, with ``interval`` seconds of interval. **中文文档** 以 ``interval`` 中定义的频率按下某个tab键 ``n`` 次。 """ self.delay(pre_dl) self.k.tap_key(self.k.tab_key, n, interval) self.delay(post_dl) def up(self, n=1, interval=0, pre_dl=None, post_dl=None): """Press up key n times. **中文文档** 按上方向键 n 次。 """ self.delay(pre_dl) self.k.tap_key(self.k.up_key, n, interval) self.delay(post_dl) def down(self, n=1, interval=0, pre_dl=None, post_dl=None): """Press down key n times. **中文文档** 按下方向键 n 次。 """ self.delay(pre_dl) self.k.tap_key(self.k.down_key, n, interval) self.delay(post_dl) def left(self, n=1, interval=0, pre_dl=None, post_dl=None): """Press left key n times **中文文档** 按左方向键 n 次。 """ self.delay(pre_dl) self.k.tap_key(self.k.left_key, n, interval) self.delay(post_dl) def right(self, n=1, interval=0, pre_dl=None, post_dl=None): """Press right key n times. **中文文档** 按右方向键 n 次。 """ self.delay(pre_dl) self.k.tap_key(self.k.right_key, n, interval) self.delay(post_dl) def delete(self, n=1, interval=0, pre_dl=None, post_dl=None): """Pres delete key n times. **中文文档** 按 delete 键n次。 """ self.delay(pre_dl) self.k.tap_key(self.k.delete_key, n, interval) self.delay(post_dl) def insert(self, n=1, interval=0, pre_dl=None, post_dl=None): """Pres insert key n times. **中文文档** 按 insert 键n次。 """ self.delay(pre_dl) self.k.tap_key(self.k.insert_key, n, interval) self.delay(post_dl) def home(self, n=1, interval=0, pre_dl=None, post_dl=None): """Pres home key n times. **中文文档** 按 home 键n次。 """ self.delay(pre_dl) self.k.tap_key(self.k.home_key, n, interval) self.delay(post_dl) def end(self, n=1, interval=0, pre_dl=None, post_dl=None): """Press end key n times. **中文文档** 按 end 键n次。 """ self.delay(pre_dl) self.k.tap_key(self.k.end_key, n, interval) self.delay(post_dl) def page_up(self, n=1, interval=0, pre_dl=None, post_dl=None): """Pres page_up key n times. **中文文档** 按 page_up 键n次。 """ self.delay(pre_dl) self.k.tap_key(self.k.page_up_key, n, interval) self.delay(post_dl) def page_down(self, n=1, interval=0, pre_dl=None, post_dl=None): """Pres page_down key n times. **中文文档** 按 page_down 键n次。 """ self.delay(pre_dl) self.k.tap_key(self.k.page_down, n, interval) self.delay(post_dl) #--- Keyboard Combination --- def press_and_tap(self, press_key, tap_key, n=1, interval=0, pre_dl=None, post_dl=None): """Press combination of two keys, like Ctrl + C, Alt + F4. The second key could be tapped for multiple time. Examples:: bot.press_and_tap("ctrl", "c") bot.press_and_tap("shift", "1") **中文文档** 按下两个键的组合键。 """ press_key = self._parse_key(press_key) tap_key = self._parse_key(tap_key) self.delay(pre_dl) self.k.press_key(press_key) self.k.tap_key(tap_key, n, interval) self.k.release_key(press_key) self.delay(post_dl) def press_two_and_tap(self, press_key1, press_key2, tap_key, n=1, interval=0, pre_dl=None, post_dl=None): """Press combination of three keys, like Ctrl + Shift + C, The tap key could be tapped for multiple time. Examples:: bot.press_and_tap("ctrl", "shift", "c") **中文文档** 按下三个键的组合键。 """ press_key1 = self._parse_key(press_key1) press_key2 = self._parse_key(press_key2) tap_key = self._parse_key(tap_key) self.delay(pre_dl) self.k.press_key(press_key1) self.k.press_key(press_key2) self.k.tap_key(tap_key, n, interval) self.k.release_key(press_key1) self.k.release_key(press_key2) self.delay(post_dl) def ctrl_c(self, pre_dl=None, post_dl=None): """Press Ctrl + C, usually for copy. **中文文档** 按下 Ctrl + C 组合键, 通常用于复制。 """ self.delay(pre_dl) self.k.press_key(self.k.control_key) self.k.tap_key("c") self.k.release_key(self.k.control_key) self.delay(post_dl) def ctrl_v(self, pre_dl=None, post_dl=None): """Press Ctrl + V, usually for paste. **中文文档** 按下 Ctrl + V 组合键, 通常用于粘贴。 """ self.delay(pre_dl) self.k.press_key(self.k.control_key) self.k.tap_key("v") self.k.release_key(self.k.control_key) self.delay(post_dl) def ctrl_x(self, pre_dl=None, post_dl=None): """Press Ctrl + X, usually for cut. **中文文档** 按下 Ctrl + X 组合键, 通常用于剪切。 """ self.delay(pre_dl) self.k.press_key(self.k.control_key) self.k.tap_key("x") self.k.release_key(self.k.control_key) self.delay(post_dl) def ctrl_z(self, pre_dl=None, post_dl=None): """Press Ctrl + Z, usually for undo. **中文文档** 按下 Ctrl + Z 组合键, 通常用于撤销上一次动作。 """ self.delay(pre_dl) self.k.press_key(self.k.control_key) self.k.tap_key("z") self.k.release_key(self.k.control_key) self.delay(post_dl) def ctrl_y(self, pre_dl=None, post_dl=None): """Press Ctrl + Y, usually for redo. **中文文档** 按下 Ctrl + Y 组合键, 通常用于重复上一次动作。 """ self.delay(pre_dl) self.k.press_key(self.k.control_key) self.k.tap_key("y") self.k.release_key(self.k.control_key) self.delay(post_dl) def ctrl_a(self, pre_dl=None, post_dl=None): """Press Ctrl + A, usually for select all. **中文文档** 按下 Ctrl + A 组合键, 通常用于选择全部。 """ self.delay(pre_dl) self.k.press_key(self.k.control_key) self.k.tap_key("a") self.k.release_key(self.k.control_key) self.delay(post_dl) def ctrl_f(self, pre_dl=None, post_dl=None): """Press Ctrl + F, usually for search. **中文文档** 按下 Ctrl + F 组合键, 通常用于搜索。 """ self.delay(pre_dl) self.k.press_key(self.k.control_key) self.k.tap_key("f") self.k.release_key(self.k.control_key) self.delay(post_dl) def ctrl_fn(self, i, pre_dl=None, post_dl=None): """Press Ctrl + Fn1 ~ 12 once. **中文文档** 按下 Ctrl + Fn1 ~ 12 组合键。 """ self.delay(pre_dl) self.k.press_key(self.k.control_key) self.k.tap_key(self.k.function_keys[i]) self.k.release_key(self.k.control_key) self.delay(post_dl) def alt_fn(self, i, pre_dl=None, post_dl=None): """Press Alt + Fn1 ~ 12 once. **中文文档** 按下 Alt + Fn1 ~ 12 组合键。 """ self.delay(pre_dl) self.k.press_key(self.k.alt_key) self.k.tap_key(self.k.function_keys[i]) self.k.release_key(self.k.alt_key) self.delay(post_dl) def shift_fn(self, i, pre_dl=None, post_dl=None): """Press Shift + Fn1 ~ 12 once. **中文文档** 按下 Shift + Fn1 ~ 12 组合键。 """ self.delay(pre_dl) self.k.press_key(self.k.shift_key) self.k.tap_key(self.k.function_keys[i]) self.k.release_key(self.k.shift_key) self.delay(post_dl) def alt_tab(self, n=1, pre_dl=None, post_dl=None): """Press Alt + Tab once, usually for switching between windows. Tab can be tapped for n times, default once. **中文文档** 按下 Alt + Tab 组合键, 其中Tab键按 n 次, 通常用于切换窗口。 """ self.delay(pre_dl) self.k.press_key(self.k.alt_key) self.k.tap_key(self.k.tab_key, n=n, interval=0.1) self.k.release_key(self.k.alt_key) self.delay(post_dl) #--- Other --- def type_string(self, text, interval=0, pre_dl=None, post_dl=None): """Enter strings. **中文文档** 从键盘输入字符串, interval是字符间输入时间间隔, 单位是秒。 """ self.delay(pre_dl) self.k.type_string(text, interval) self.delay(post_dl) def copy_text_to_clipboard(self, text): """Copy text to clipboard. **中文文档** 拷贝字符串到剪贴板。 """ pyperclip.copy(text)
from pymouse import PyMouse mouse = PyMouse() x_dim, y_dim = mouse.screen_size() x = x_dim / 2 y = y_dim / 2 mouse.move(x,y)
def mainLoop(par, kill, key, user, argMode): if par['step'] < calibration['final']: cv2.namedWindow('frame0', cv2.WINDOW_NORMAL) cv2.namedWindow('frame1', cv2.WINDOW_NORMAL) # load parameters with open("./configuration/" + user + ".json") as json_data_file: data = json.load(json_data_file) para = data['ctrl'] depth = data['depth'] handBgstPara0 = data['hand'][0] handBgstPara1 = data['hand'][1] prIdPara0 = data['lc'][0] prIdPara1 = data['lc'][1] # set system paramteres mouse = PyMouse() width, height = mouse.screen_size() camw = 320 camh = 240 camfps = 200 crop = [[0, 150, 30, 240], [160, 310, 30, 240]] active = [0, 130, 125, 225] activeShape = (active[1] - active[0], active[3] - active[2]) mode = argMode # 0 for absolute; 1 for relative sizex = 15 sizey = 30 # set user parameters # cams par['gain'] = para['gain'] # hands par['sbsThreshL'] = [ handBgstPara0['sbsThreshL'], handBgstPara1['sbsThreshL'] ] par['sbsThreshH'] = [ handBgstPara0['sbsThreshH'], handBgstPara1['sbsThreshH'] ] par['sbsGause'] = [handBgstPara0['sbsGause'], handBgstPara1['sbsGause']] # fingertips par['ydis'] = prIdPara0['ydis'] par['yth'] = prIdPara0['yth'] # depth par['touch'] = depth['thresh'] # set cams cap0 = cv2.VideoCapture(1) setCam(cap0, para['gain'][0], camw, camh, camfps) cap1 = cv2.VideoCapture(2) setCam(cap1, para['gain'][1], camw, camh, camfps) # to be checked # initialize variables dat = dict() dat['pointing'] = True dat['depth'] = 0 dat['absDepth'] = 0 dat['touch'] = False dat['position'] = [0, 0] pre0 = (0, 0) pre1 = (0, 0) preF0 = [0, 0] preF1 = [0, 0] plane = False dis01 = (0, 0) manule = False x0, y0, x1, y1 = [collections.deque() for i in xrange(4)] setYth = False # initialize modules dp.init(user, camw) handBgst0 = BackgroundSubtractor(type='sbs', sbsThreshL=handBgstPara0['sbsThreshL'], sbsThreshH=handBgstPara0['sbsThreshH'], gause=handBgstPara0['sbsGause']) handBgst1 = BackgroundSubtractor(type='sbs', sbsThreshL=handBgstPara1['sbsThreshL'], sbsThreshH=handBgstPara1['sbsThreshH'], gause=handBgstPara1['sbsGause']) # options if par['step'] > calibration['getBg']: handBgst0.setBgM(cap0, 20) handBgst1.setBgM(cap1, 20) print "tracking..." fps = FPS().start() while True: if kill['kill']: break fps.update() if par['step'] == calibration['final']: if key['status']: if key['info'] == "<esc>": break elif key['info'] == '<space>' and dat['pointing']: mouse.click(mouse.position()[0], mouse.position()[1], 1) elif key['info'] == '<tab>': dat['pointing'] = not dat['pointing'] dat['position'] = list(mouse.position()) key['status'] = False # image processing ret, _frame0 = cap0.read() ret, _frame1 = cap1.read() if par['step'] == calibration['position']: cv2.line(_frame0, (crop[0][0], crop[0][2]), (crop[0][0], crop[0][3]), colors.colors['pink'], 1) cv2.line(_frame0, (crop[0][1], crop[0][2]), (crop[0][1], crop[0][3]), colors.colors['pink'], 1) cv2.line(_frame0, (crop[0][0], crop[0][2]), (crop[0][1], crop[0][2]), colors.colors['pink'], 1) cv2.line(_frame0, (crop[0][0], crop[0][3]), (crop[0][1], crop[0][3]), colors.colors['pink'], 1) # cv2.line(_frame1, (crop[1][0], crop[1][2]), (crop[1][0], crop[1][3]), colors.colors['pink'], 1) cv2.line(_frame1, (crop[1][1], crop[1][2]), (crop[1][1], crop[1][3]), colors.colors['pink'], 1) cv2.line(_frame1, (crop[1][0], crop[1][2]), (crop[1][1], crop[1][2]), colors.colors['pink'], 1) cv2.line(_frame1, (crop[1][0], crop[1][3]), (crop[1][1], crop[1][3]), colors.colors['pink'], 1) # cv2.line(_frame0, (active[0], active[2]), (active[0], active[3]), colors.colors['green'], 2) cv2.line(_frame0, (active[1], active[2]), (active[1], active[3]), colors.colors['green'], 2) cv2.line(_frame0, (active[0], active[2]), (active[1], active[2]), colors.colors['green'], 2) cv2.line(_frame0, (active[0], active[3]), (active[1], active[3]), colors.colors['green'], 2) cv2.imshow("frame0", _frame0) cv2.imshow("frame1", _frame1) k = cv2.waitKey(1) if k == 27: # esc break if k == 195: # f6 par['step'] = calibration['gain'] continue frame0 = _frame0[crop[0][2]:crop[0][3], crop[0][0]:crop[0][1]] frame1 = _frame1[crop[1][2]:crop[1][3], crop[1][0]:crop[1][1]] if par['step'] == calibration['gain'] and not manule: setGain(frame0, frame1, para['gain'], cap0, cap1, crop) print "[calibration] cams gain SET " + str(para['gain']) par['gain'] = para['gain'] k = cv2.waitKey() if k == 27: break if k == 192: #f3 manule = True if k == 195: par['step'] = calibration['threshL0'] continue if par['step'] == calibration['threshL0']: gray = cv2.cvtColor(frame0, cv2.COLOR_BGR2GRAY) valid = cv2.threshold(gray, 60, 255, cv2.THRESH_BINARY)[1] grayBlur = cv2.blur(gray, (par['sbsGause'][0], par['sbsGause'][0])) thresh = cv2.threshold(grayBlur, par['sbsThreshL'][0], 255, cv2.THRESH_BINARY)[1] cv2.imshow("frame0", frame0) cv2.imshow("valid", valid) cv2.imshow("thresh", thresh) preFingers0 = lcid.preIndexUD(thresh.copy(), frame0, 300, 2, prIdPara0['Uthresh'], prIdPara0['Dthresh']) if len(preFingers0) == 0: continue elif len(preFingers0) == 1: finIndex0 = prlc.prlc("notsmooth", cnt=preFingers0[0]) else: finIndex0 = prlc.prlc("notsmooth", cnt=preFingers0[1]) indexRecc = mcv.getRec(finIndex0, sizex, sizey, thresh.shape) mthresh = thresh[indexRecc[2]:indexRecc[3], indexRecc[0]:indexRecc[1]] mvalid = valid[indexRecc[2]:indexRecc[3], indexRecc[0]:indexRecc[1]] cv2.imshow("area", mthresh) cv2.imshow("areaT", mvalid) broken = mcv.broken(mthresh, sizex * sizey / 25) area = mcv.area(mthresh) areaT = mcv.area(mvalid) if broken or area < areaT * 0.6: par['sbsThreshL'] = [ par['sbsThreshL'][0] - 2, par['sbsThreshL'][1] ] cv2.rectangle(frame0, (indexRecc[0], indexRecc[2]), (indexRecc[1], indexRecc[3]), colors.colors['green']) cv2.putText(frame0, str(par['sbsThreshL'][0]) + " " + str(broken), (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText(frame0, str(area) + " " + str(areaT), (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.imshow("frame0", frame0) k = cv2.waitKey(1) if k == 194: #f5 reset par['sbsThreshL'] = [100, par['sbsThreshL'][1]] if k == 195: par['sbsThreshL'] = [ par['sbsThreshL'][0] - 2, par['sbsThreshL'][1] ] par['step'] = calibration['threshL1'] if k == 27: break continue if par['step'] == calibration['threshL1']: gray = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY) valid = cv2.threshold(gray, 60, 255, cv2.THRESH_BINARY)[1] grayBlur = cv2.blur(gray, (par['sbsGause'][1], par['sbsGause'][1])) thresh = cv2.threshold(grayBlur, par['sbsThreshL'][1], 255, cv2.THRESH_BINARY)[1] cv2.imshow("frame1", frame1) cv2.imshow("valid", valid) cv2.imshow("thresh", thresh) preFingers1 = lcid.preIndexUD(thresh.copy(), frame1, 300, 2, prIdPara1['Uthresh'], prIdPara1['Dthresh']) if len(preFingers1) == 0: continue elif len(preFingers1) == 1: finIndex1 = prlc.prlc("notsmooth", cnt=preFingers1[0]) else: finIndex1 = prlc.prlc("notsmooth", cnt=preFingers1[1]) indexRecc = mcv.getRec(finIndex1, sizex, sizey, thresh.shape) mthresh = thresh[indexRecc[2]:indexRecc[3], indexRecc[0]:indexRecc[1]] mvalid = valid[indexRecc[2]:indexRecc[3], indexRecc[0]:indexRecc[1]] cv2.imshow("area", mthresh) cv2.imshow("areaT", mvalid) broken = mcv.broken(mthresh, sizex * sizey / 25) area = mcv.area(mthresh) areaT = mcv.area(mvalid) if broken or area < areaT * 0.6: par['sbsThreshL'] = [ par['sbsThreshL'][0], par['sbsThreshL'][1] - 2 ] cv2.rectangle(frame1, (indexRecc[0], indexRecc[2]), (indexRecc[1], indexRecc[3]), colors.colors['green']) cv2.putText(frame1, str(par['sbsThreshL'][1]) + " " + str(broken), (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText(frame1, str(area) + " " + str(areaT), (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.imshow("frame1", frame1) k = cv2.waitKey(1) if k == 194: #f5 reset par['sbsThreshL'] = [par['sbsThreshL'][0], 100] if k == 195: par['sbsThreshL'] = [ par['sbsThreshL'][0], par['sbsThreshL'][1] - 2 ] handBgst0.setThresh(par['sbsThreshL'][0], par['sbsThreshH'][0]) handBgst1.setThresh(par['sbsThreshL'][1], par['sbsThreshH'][1]) par['step'] = calibration['getBg'] if k == 27: break continue if par['step'] == calibration['getBg']: cv2.imshow("frame0", frame0) cv2.imshow("frame1", frame1) k = cv2.waitKey(1) if k == 27: break elif k == 192: #f3 handBgst0.setBgM(cap0, 20) handBgst1.setBgM(cap1, 20) print "[calibration] bg done" elif k == 195: par['step'] = calibration['threshH'] continue hand0 = handBgst0.bgst(_frame0) hand1 = handBgst1.bgst(_frame1) hand0 = hand0[crop[0][2]:crop[0][3], crop[0][0]:crop[0][1]] hand1 = hand1[crop[1][2]:crop[1][3], crop[1][0]:crop[1][1]] if par['step'] == calibration['threshH']: if not mcv.clean(hand0): par['sbsThreshH'] = [ par['sbsThreshH'][0] - 2, par['sbsThreshH'][1] ] handBgst0.setThresh(par['sbsThreshL'][0], par['sbsThreshH'][0]) print par['sbsThreshH'] if not mcv.clean(hand1): par['sbsThreshH'] = [ par['sbsThreshH'][0], par['sbsThreshH'][1] - 2 ] handBgst1.setThresh(par['sbsThreshL'][1], par['sbsThreshH'][1]) print par['sbsThreshH'] cv2.imshow("frame0", _frame0) cv2.imshow("frame1", _frame1) cv2.imshow("hand0", hand0) cv2.imshow("hand1", hand1) k = cv2.waitKey(1) if k == 27: break elif k == 194: #f5 par['sbsThreshH'] = [255, 255] handBgst0.setThresh(par['sbsThreshL'][0], par['sbsThreshH'][0]) handBgst1.setThresh(par['sbsThreshL'][1], par['sbsThreshH'][1]) elif k == 195: print "[calibration] set threshHigh " + str(par['sbsThreshH']) par['step'] = calibration['yth'] continue preFingers0 = lcid.preIndexUD(hand0, frame0, 300, par['step'], prIdPara0['Uthresh'], prIdPara0['Dthresh']) preFingers1 = lcid.preIndexUD(hand1, frame1, 300, par['step'], prIdPara1['Uthresh'], prIdPara1['Dthresh']) # locating tip finThumb0 = (0, 0) finThumb1 = (0, 0) if len(preFingers0) == 0: finIndex0 = pre0 elif len(preFingers0) == 1: finIndex0 = prlc.prlc("notsmooth", cnt=preFingers0[0], img=frame0, textPos=40) else: finThumb0 = prlc.prlc("notsmooth", cnt=preFingers0[0], img=frame0, textPos=20) finIndex0 = prlc.prlc("notsmooth", cnt=preFingers0[1], img=frame0, textPos=40) cv2.putText( frame0, str(mcv.ptoint(finIndex0)[0]) + " " + str(mcv.ptoint(finIndex0)[1]), (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText( frame0, str(mcv.ptoint(finThumb0)[0]) + " " + str(mcv.ptoint(finThumb0)[1]), (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.circle(frame0, mcv.ptoint(finIndex0), 2, colors.colors['white'], -1) cv2.circle(frame0, mcv.ptoint(finThumb0), 2, colors.colors['white'], -1) if finIndex0[1] - finThumb0[1] < prIdPara0['ydis'] and finThumb0[ 1] > prIdPara0['yth']: finIndex0 = finThumb0 if finIndex0[1] < finThumb0[1]: finIndex0 = finThumb0 cv2.circle(frame0, mcv.ptoint(finIndex0), 3, colors.colors['yellow'], -1) pre0 = finIndex0 # continue if len(preFingers1) == 0: finIndex1 = pre1 elif len(preFingers1) == 1: finIndex1 = prlc.prlc("notsmooth", cnt=preFingers1[0], img=frame1, textPos=40) else: finThumb1 = prlc.prlc("notsmooth", cnt=preFingers1[0], img=frame1, textPos=20) finIndex1 = prlc.prlc("notsmooth", cnt=preFingers1[1], img=frame1, textPos=40) if par['step'] == calibration['yth']: cv2.putText( frame1, str(mcv.ptoint(finIndex1)[0]) + " " + str(mcv.ptoint(finIndex1)[1]), (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText( frame1, str(mcv.ptoint(finThumb1)[0]) + " " + str(mcv.ptoint(finThumb1)[1]), (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.circle(frame1, mcv.ptoint(finIndex1), 2, colors.colors['white'], -1) cv2.circle(frame1, mcv.ptoint(finThumb1), 2, colors.colors['white'], -1) if mcv.distance(finIndex0, mcv.subt( finThumb1, dis01)) < mcv.distance( finIndex0, mcv.subt(finIndex1, dis01)): ## dis finIndex1 = finThumb1 cv2.circle(frame1, mcv.ptoint(finIndex1), 3, colors.colors['yellow'], -1) pre1 = finIndex1 if par['step'] == calibration['yth']: cv2.rectangle(_frame0, (active[0], active[2]), (active[1], active[3]), colors.colors['green']) if setYth: par['yth'] = max(finThumb0[1], par['yth']) cv2.putText(frame0, str(setYth) + " " + str(par['yth']), (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.imshow("frame0", frame0) cv2.imshow("frame1", frame1) k = cv2.waitKey(1) if k == 192: #f3 setYth = not setYth if k == 194: #f5 par['yth'] = active[2] - crop[0][2] if k == 195: par['step'] = calibration['plane'] if k == 27: break continue finIndex0 = [finIndex0[0] + crop[0][0], finIndex0[1] + crop[0][2]] finIndex1 = [finIndex1[0] + crop[1][0], finIndex1[1] + crop[1][2]] if par['step'] == calibration['plane']: preF0 = finIndex0 preF1 = finIndex1 if plane: x0.append(finIndex0[0]) y0.append(finIndex0[1]) x1.append(finIndex1[0]) y1.append(finIndex1[1]) dep = dp.depthEstimate(finIndex0[0], finIndex0[1], finIndex1[0], finIndex1[1]) cv2.putText(frame0, str(dep), (10, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.rectangle(_frame0, (active[0], active[2]), (active[1], active[3]), colors.colors['green']) cv2.imshow("frame0", frame0) cv2.imshow("frame1", frame1) k = cv2.waitKey(1) if k == 27: break if k == 192: # f3 if plane: print "end recording" dp.keybplaneCalcN((x0, y0, x1, y1)) ## para x0, y0, x1, y1 = [collections.deque() for i in xrange(4)] plane = False else: print "start recording" plane = True if k == 195: par['step'] = calibration['depth'] continue dp.getTouch(finIndex0, finIndex1, preF0, preF1, par['alpha'], dat, depth['l'], depth['h'], par['touch'], active) if par['step'] == calibration['depth']: preF0 = finIndex0 preF1 = finIndex1 cv2.circle(_frame0, (int(finIndex0[0]), int(finIndex0[1])), 3, colors.colors['yellow'], -1) cv2.circle(_frame1, (int(finIndex1[0]), int(finIndex1[1])), 3, colors.colors['yellow'], -1) cv2.rectangle(_frame0, (active[0], active[2]), (active[1], active[3]), colors.colors['green']) cv2.putText(_frame0, str(dat['depth']), (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText(_frame0, str(dat['touch']), (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText( _frame0, str(dat['position'][0]) + " " + str(dat['position'][1]), (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.imshow("frame0", _frame0) cv2.imshow("frame1", _frame1) k = cv2.waitKey(1) if k == 27: break continue if dat['touch'] and dat['pointing'] and par['step'] == calibration[ 'final']: if mode == 0: # absolute dat['position'][0] = finIndex0[0] dat['position'][1] = finIndex0[1] dat['position'][0] = (active[1] - dat['position'][0] + 0.0) * width / activeShape[0] dat['position'][1] = (active[3] - dat['position'][1] + 0.0) * height / activeShape[1] mouse.move(dat['position'][0], dat['position'][1]) if mode == 1: # relative delta = list(mcv.subt(preF0, finIndex0)) delta[0] = delta[0] * (width + 0.0) / activeShape[0] delta[1] = delta[1] * (height + 0.0) / activeShape[1] dat['position'] = list(mcv.addt(dat['position'], delta)) if dat['position'][0] > width: dat['position'][0] = width if dat['position'][1] > height: dat['position'][1] = height if dat['position'][0] < 0: dat['position'][0] = 0 if dat['position'][1] < 0: dat['position'][1] = 0 mouse.move(dat['position'][0], dat['position'][1]) preF0 = finIndex0 preF1 = finIndex1 para['gain'] = par['gain'] handBgstPara0['sbsThreshL'] = par['sbsThreshL'][0] handBgstPara1['sbsThreshL'] = par['sbsThreshL'][1] handBgstPara0['sbsThreshH'] = par['sbsThreshH'][0] handBgstPara1['sbsThreshH'] = par['sbsThreshH'][1] prIdPara0['yth'] = par['yth'] with open("./configuration/" + user + ".json", 'w') as f: js = { 'ctrl': para, 'depth': depth, 'hand': [handBgstPara0, handBgstPara1], 'lc': [prIdPara0, prIdPara1] } json.dump(js, f) print("write to file") fps.stop() print("[TEST1] elasped time: {:.2f}".format(fps.elapsed())) print("[TEST1] approx. FPS: {:.2f}".format(fps.fps())) kill['kill'] = True cap0.release() cap1.release() cv2.destroyAllWindows()
from pymouse import PyMouse from pykeyboard import PyKeyboard m = PyMouse() k = PyKeyboard() # pressing a key k.press_key('H') # which you then follow with a release of the key k.release_key('H') # or you can 'tap' a key which does both k.tap_key('e') # note that that tap_key does support a way of repeating keystrokes with a interval time between each k.tap_key('l', n=2, interval=1) # and you can send a string if needed too k.type_string('o World!') # move the mouse to int x and int y (these are absolute positions) m.move(200, 200) # click works about the same, except for int button possible values are 1: left, 2: right, 3: middle m.click(600, 900, 1) # get the screen size m.screen_size() # (1024, 768) # get the mouse positionHello World!Hello World! m.position() # (500, 300)lo World!
import cv2 import numpy as np from pymouse import PyMouse m = PyMouse() vid = cv2.VideoCapture(0) screen_size = m.screen_size() pos = m.position() mx = pos[0] my = pos[1] while True: flag, frame = vid.read() face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt.xml') eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml') if flag: gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) eyes = None center = [] xpt = [] nxpt = [] ypt =[] nypt = [] mask = np.array([]) # Find face for (x, y, w, h) in faces: cv2.rectangle(frame, (x,y), (x+w,y+h/2), (255,0,0), 2) roi_gray = np.zeros(gray.shape, np.uint8)
# -*- coding: cp936 -*- from pymouse import PyMouse import socket import json UDP_IP = '0.0.0.0' UDP_PORT = 5000 sock = socket.socket( socket.AF_INET, # Internet socket.SOCK_DGRAM) # UDP sock.settimeout(1) sock.bind((UDP_IP, UDP_PORT)) m = PyMouse() x_max, y_max = m.screen_size() SCALE = 5 X_SCALE = -(1.0 / 2.0 / 3.14159) * x_max * SCALE Y_SCALE = -(1.0 / 2.0 / 3.14159) * y_max * SCALE while True: pos = [0, 0] try: print "\n" data, addr = sock.recvfrom( 1024) # buffer size is 1024 bytes data = data.split(',') data = "[" + data + "]" data = json.loads(data) pos[0] = int(data[2] * X_SCALE + 0.5 * x_max) pos[1] = int(data[0] * Y_SCALE + 0.5 * y_max)
# import the module from pymouse import PyMouse # instantiate an mouse object m = PyMouse() # move the mouse to int x and int y (these are absolute positions) m.move(200, 200) # click works about the same, except for int button possible values are 1: left, 2: middle, 3: right m.click(500, 300, 1) # get the screen size m.screen_size() # (1024, 768) # get the mouse position m.position() # (500, 300)
from pymouse import PyMouse from pykeyboard import PyKeyboard import time m = PyMouse() k = PyKeyboard() x_dim, y_dim = m.screen_size() print(m.screen_size()) print(x_dim) print(y_dim) time.sleep(2) def main(): try: for i in range(40): print(i) print("reward3") k.tab_key("H") time.sleep(4) print("startbattle") k.tab_key("I") time.sleep(7) print("begin") k.tab_key("o") time.sleep(69) print("reward1")
from pymouse import PyMouse mouse = PyMouse() x_dim, y_dim = mouse.screen_size() x = x_dim / 2 y = y_dim / 2 mouse.move(x, y)
""" Created on 2015. 5. 12. @author: Administrator """ from pymouse import PyMouse from pykeyboard import PyKeyboard m = PyMouse() k = PyKeyboard() x_dim, y_dim = m.screen_size() print x_dim print y_dim m.click(x_dim / 2, y_dim / 2, 1) k.type_string("Hello, World!") x, y = m.position() print x print y
def irMouse(): """Open webcam, track IR movements, and move the mouse pointer accordingly. Returns: 0 on success, -1 otherwise """ retval = 0 # Open up a webcam capture capture = cv2.VideoCapture(0) # Reduce video size for faster processing capture.set(cv2.CAP_PROP_FRAME_WIDTH, 600) capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 450) # Create windows cv2.namedWindow('Hue', flags=cv2.WINDOW_AUTOSIZE) cv2.namedWindow('Saturation', flags=cv2.WINDOW_AUTOSIZE) cv2.namedWindow('Value', flags=cv2.WINDOW_AUTOSIZE) cv2.namedWindow('Composite', flags=cv2.WINDOW_AUTOSIZE) cv2.namedWindow('Tracking', flags=cv2.WINDOW_AUTOSIZE) # Spread out the windows a bit so they're not directly on top of each other cv2.moveWindow('Tracking', 0, 0) cv2.moveWindow('Composite', 400, 0) cv2.moveWindow('Value', 0, 340) cv2.moveWindow('Hue', 400, 340) cv2.moveWindow('Saturation', 800, 340) # Add trackbars to make on-the-fly testing easier. After you've found # values that work for your own environment, you'll probably want to change # the default values here cv2.createTrackbar('hmin', 'Hue', 141, 255, lambda *args: None) cv2.createTrackbar('hmax', 'Hue', 255, 255, lambda *args: None) cv2.createTrackbar('smin', 'Saturation', 25, 255, lambda *args: None) cv2.createTrackbar('smax', 'Saturation', 57, 255, lambda *args: None) cv2.createTrackbar('vmin', 'Value', 237, 255, lambda *args: None) cv2.createTrackbar('vmax', 'Value', 255, 255, lambda *args: None) mouse = PyMouse() screenSize = mouse.screen_size() newLoc = (0, 0) print("Running, press q to exit...") # Loop infinitely reading webcam data until user presses Escape while True: ret, frame = capture.read() if ret == True: # Convert capture to hue, saturation, value hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) hue, sat, val = cv2.split(hsv) # Get threshold values from trackbars hmin = cv2.getTrackbarPos('hmin', 'Hue') hmax = cv2.getTrackbarPos('hmax', 'Hue') smin = cv2.getTrackbarPos('smin', 'Saturation') smax = cv2.getTrackbarPos('smax', 'Saturation') vmin = cv2.getTrackbarPos('vmin', 'Value') vmax = cv2.getTrackbarPos('vmax', 'Value') # Apply thresholding values hthresh = cv2.inRange(np.array(hue), np.array(hmin), np.array(hmax)) sthresh = cv2.inRange(np.array(sat), np.array(smin), np.array(smax)) vthresh = cv2.inRange(np.array(val), np.array(vmin), np.array(vmax)) # AND value and hue composite = cv2.bitwise_and(vthresh, hthresh) # Do some morphological transformations to clean up image kernel = np.ones((5, 5), np.uint8) composite = cv2.dilate(composite, kernel, iterations=1) composite = cv2.morphologyEx(composite, cv2.MORPH_CLOSE, kernel) # Use big kernel for blurring argRad = 55 composite = cv2.GaussianBlur(composite, (argRad, argRad), 0) prevLoc = newLoc # Get the maximum location (_, _, _, newLoc) = cv2.minMaxLoc(composite) # Only proceed if we are NOT at the top left (i.e., default) corner if newLoc != (0, 0) and prevLoc != (0, 0): # Calculate x-axis and y-axis changes between prevLoc and newLoc delta = np.subtract(newLoc, prevLoc) # Calculate actual distance between prevLoc and newLoc distance = cv2.norm(newLoc, prevLoc) # Has the IR pointer moved a "reasonable" distance? If so, move the mouse pointer if distance > 3: if args.opt_verbose == True: print("IR pointer moved {0}".format(distance)) # Set the scale factor: bigger IR moves == bigger mouse moves if distance > 20: scaleFactor = 1.7 elif distance > 9: scaleFactor = 1.4 elif distance > 6: scaleFactor = 1.2 else: scaleFactor = 1.0 # Get the mouse pointer's current location curPtr = mouse.position() #click with a IR Pointer # mouse.click(curPtr[0],curPtr[1]) if args.opt_verbose == True: print("\tMouse pointer is currently at {0}".format( curPtr)) # Calculate the new mouse pointer location newPtrX = int(curPtr[0] - (delta[0] * distance * scaleFactor)) newPtrY = int(curPtr[1] + (delta[1] * distance * scaleFactor)) # Sanity check the new pointer location values if newPtrX < 0: newPtrX = 0 if newPtrX > screenSize[0]: newPtrX = screenSize[0] if newPtrY < 0: newPtrY = 0 if newPtrY > screenSize[1]: newPtrY = screenSize[1] # Move the mouse pointer mouse.move(newPtrX, newPtrY) if args.opt_verbose == True: print("\tMoved mouse pointer to {0}, {1}".format( newPtrX, newPtrY)) # Draw circle around what we're tracking cv2.circle(frame, newLoc, 10, (128, 255, 0), 2) # Display results in windows cv2.imshow('Hue', hthresh) cv2.imshow('Saturation', sthresh) cv2.imshow('Value', vthresh) cv2.imshow('Composite', composite) cv2.imshow('Tracking', frame) # Esc key pressed? if cv2.waitKey(25) & 0xFF == ord('q'): break else: print("Webcam capture failed!") retval = -1 break # End while loop print("Exiting") cv2.destroyAllWindows() capture.release() return retval
# import the module from pymouse import PyMouse # instantiate an mouse object m = PyMouse() # move the mouse to int x and int y(these are absolute positions) # m.move(x, y) m.move(200, 300) # clock works about the same, except for int button possible values are: # 1: left, 2: middle, 3: right m.click(200, 300, 1) # get the screen size print m.screen_size() # (1366, 768) # get the mouse position print m.position()
def errReceived(self, data): print data def inConnectionLost(self): pass def outConnectionLost(self): pass def errConnectionLost(self): pass def processExited(self, reason): pass def processEnded(self, reason): print "processEnded, status %d" % (reason.value.exitCode,) print "quitting" reactor.stop() process_protocol_xinput_obj = ProcessProtocolXinput() m = PyMouse() #if starts at 0,0 at top-left corner white_board_x=5000 white_board_y=5000 #else white_board_x_min=250 white_board_x_max=500 white_board_x_diff=white_board_x_max-white_board_x_min white_board_y_min=250 white_board_y_max=500 white_board_y_diff=white_board_y_max-white_board_y_min x_screen, y_screen = m.screen_size() reactor.spawnProcess(process_protocol_xinput_obj, "xinput", ["xinput","test","14"], env=None) reactor.run()
from oscAPI import listen, readQueue, bind, init from pymouse import PyMouse M = PyMouse() W, H = M.screen_size() def main(): init() oscid = listen(port=10001) bind(oscid, update_mouse, '/update') while True: readQueue(oscid) def update_mouse(message, *args): m = message[2:] print m x, y = M.position() M.move(x + m[0] * 10 - 5, y + m[1] * 10 - 5) if __name__ == '__main__': main()
from pykeyboard import PyKeyboard from time import sleep from copy import deepcopy # Input init # Ref: https://github.com/PyUserInput/PyUserInput # Usage: # m.click(0, 0, 1) 使用 X11 坐标 # k.type_string('Hello, World!') m = PyMouse() k = PyKeyboard() # Screen detection print('[加载]屏幕参数') x11_x, x11_y = m.screen_size() pil_x, pil_y = ImageGrab.grab().size DPI_times = pil_x / x11_x EMULATOR_HEADER = 39 EMULATOR_BOTTOM = 42 cv2.namedWindow('output', cv2.WINDOW_NORMAL) cv2.resizeWindow('output', 500, 500) cv2.moveWindow('output', int(x11_x) - 500, int(x11_y) - 500) print('[加载]X11 size:', (x11_x, x11_y)) print('[加载]PIL size:', ImageGrab.grab().size) print('[加载]DPI times:', DPI_times) # Helpers - 图像处理 screen_data = None
from pymouse import PyMouse from pykeyboard import PyKeyboard import time import os import shutil m = PyMouse() k = PyKeyboard() x_dim, y_dim = m.screen_size() # click DCA1000RAM m.click(x_dim//2-150, y_dim//2-120, 1) ## record the click time and click trigger m.click(x_dim//2-70, y_dim//2-100, 1) t1 = time.time() ## save time t1 record_flag = input('Finished recording data? (y/n) ') if not record_flag is 'y': print("Data recording is not finished! Quit...") quit() # if yes, continue time_modif = os.path.getmtime('C:/ti/mmwave_studio_01_00_00_00/mmWaveStudio/PostProc/adc_data_Raw_0.bin') print('The creation time of this radar data is ',time_modif,'. Is this correct?') # if yes, continue ## then packet reorder and zero fill # os.system('cd C:/ti/mmwave_studio_01_00_00_00/mmWaveStudio/PostProc')
if (submitpos['confidence'] > CONFIDENCE): m.press(submitpos['result'][0], submitpos['result'][1]) print(u'>>交卷') else: logging.error(u'未找到交卷按钮') else: logging.error(u'无法定位到交卷按钮') time.sleep(2) #点击确定 get_screenshot() imsrc = ac.imread(sc_path) imyes = ac.imread('C:/yes.jpg') yespos = ac.find_template(imsrc, imyes) if yespos is not None: logging.debug(u'确定按钮相似度%f' % yespos['confidence']) if (yespos['confidence'] > CONFIDENCE): m.press(yespos['result'][0], yespos['result'][1]) print(u'>>完成答题') else: logging.error(u'未找到确定按钮') else: logging.error(u'无法定位到确定按钮') if __name__ == '__main__': logging.info(u'当前屏幕分辨率为{}'.format(m.screen_size())) get_answer() print(u'>>>开始答题,请在3秒内将桌面切换为答题界面...') time.sleep(3) loop_answer() submit_answer()
#!/usr/bin/python from pymouse import PyMouse from pykeyboard import PyKeyboard from time import sleep m = PyMouse() k = PyKeyboard() xd, yd = m.screen_size() k.tap_key(k.function_keys[11]) print xd print yd sleep(1) m.click(1500, 1080, 1)
def run(self): global running global movingX global movingY movingX=0 movingY=0 m=PyMouse() steps=1 last_time = datetime.datetime.now() measure = str(datetime.datetime.now() - last_time).split(":", 1)[1].split(":", 1)[1] row,col = "000","000" X,Y,CX,CY,LX,LY,dirX,dirY=0,0,0,0,0,0,0,0 max_steps=120 self.open_socket() input = [self.server,sys.stdin] running = 1 screen_dim = m.screen_size() print "Screen Xdim = " + str(screen_dim[0]) print "Screen Ydim = " + str(screen_dim[1]) while running: inputready,outputready,exceptready = select.select(input,[],[]) for s in inputready: if s == self.server: a=self.server.recv(self.size) if re.match("ROW", str(a)) is not None: row = a.split("ROW",1)[1] if re.match("COL", str(a)) is not None: col = a.split("COL",1)[1] cursor=[col, row] if cursor[0] is not None and cursor[1] is not None : X=int(cursor[0])-int(LX) Y=int(cursor[1])-int(LY) measure = str(datetime.datetime.now() - last_time).split(":", 1)[1].split(":", 1)[1] print "measure = " + str(measure) if float(measure) <= 0.0005 and steps < max_steps: steps=steps+4 elif float(measure) <= 0.001 and steps < max_steps:steps=steps+1.3 elif float(measure) <= 0.0015 and steps < max_steps:steps=steps+1.25 elif float(measure) <= 0.010 and steps < max_steps:steps=steps+1.2 elif float(measure) <= 0.020 and steps < max_steps:steps=steps+1.15 elif float(measure) <= 0.030 and steps < max_steps:steps=steps+1.1 elif float(measure) <= 0.040 and steps < max_steps:steps=steps+1.05 elif float(measure) <= 0.050 and steps < max_steps:steps=steps+1 else:steps=0.5 if X<0: dirX=-1 print "calling MoveX" MoveX(m,dirX,steps,screen_dim).start() if X>0: dirX=1 print "calling MoveX" MoveX(m,dirX,steps,screen_dim).start() if X==0: dirX=0 if Y<0: dirY=-1 print "calling MoveY" MoveY(m,dirY,steps,screen_dim).start() if Y>0: dirY=1 print "calling MoveY" MoveY(m,dirY,steps,screen_dim).start() if Y==0: dirY=0 last_time = datetime.datetime.now() LX=cursor[0] LY=cursor[1] print "\n" elif s == sys.stdin: junk = sys.stdin.readline()