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()
