TestMu Conference is Back! Future of Testing + AI
How to use gesture method in uiautomator
Best Python code snippet using uiautomator
test_flow.py
Source:test_flow.py 
1# -*- coding: utf-8 -*-2# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.3# Use of this source code is governed by a BSD-style license that can be4# found in the LICENSE file.5"""Guide the user to perform gestures. Record and validate the gestures."""6import fcntl7import glob8import os9import subprocess10import sys11import common_util12import firmware_log13import firmware_utils14import fuzzy15import mini_color16import mtb17import touchbotII_robot_wrapper as robot_wrapper18import test_conf as conf19import validators20from firmware_utils import GestureList21sys.path.append('../../bin/input')22import input_device23# Include some constants24from firmware_constants import DEV, GV, MODE, OPTIONS, TFK25class TestFlow:26 """Guide the user to perform gestures. Record and validate the gestures."""27 def __init__(self, device_geometry, device, keyboard, win, parser, output,28 test_version, board, firmware_version, options):29 self.device_geometry = device_geometry30 self.device = device31 self.device_node = self.device.device_node32 self.keyboard = keyboard33 self.firmware_version = firmware_version34 self.output = output35 self.board = board36 self.test_version = test_version37 self.output.print_report('%s' % test_version)38 self._get_record_cmd()39 self.win = win40 self.parser = parser41 self.packets = None42 self.gesture_file_name = None43 self.prefix_space = self.output.get_prefix_space()44 self.scores = []45 self.mode = options[OPTIONS.MODE]46 self.fngenerator_only = options[OPTIONS.FNGENERATOR]47 self.iterations = options[OPTIONS.ITERATIONS]48 self.replay_dir = options[OPTIONS.REPLAY]49 self.resume_dir = options[OPTIONS.RESUME]50 self.recording = not any([bool(self.replay_dir), bool(self.resume_dir)])51 self.device_type = (DEV.TOUCHSCREEN if options[OPTIONS.TOUCHSCREEN]52 else DEV.TOUCHPAD)53 self.robot = robot_wrapper.RobotWrapper(self.board, options)54 self.robot_waiting = False55 self.gv_count = float('infinity')56 gesture_names = self._get_gesture_names()57 order = None58 if self._is_robot_mode():59 order = lambda x: conf.finger_tips_required[x.name]60 self.gesture_list = GestureList(gesture_names).get_gesture_list(order)61 self._get_all_gesture_variations(options[OPTIONS.SIMPLIFIED])62 self.init_flag = False63 self.system_device = self._non_blocking_open(self.device_node)64 self.evdev_device = input_device.InputEvent()65 self.screen_shot = firmware_utils.ScreenShot(self.geometry_str)66 self.mtb_evemu = mtb.MtbEvemu(device)67 self._rename_old_log_and_html_files()68 self._set_static_prompt_messages()69 self.gesture_image_name = None70 self.gesture_continues_flag = False71 self.use_existent_event_file_flag = False72 def __del__(self):73 self.system_device.close()74 def _rename_old_log_and_html_files(self):75 """When in replay or resume mode, rename the old log and html files."""76 if self.replay_dir or self.resume_dir:77 for file_type in ['*.log', '*.html']:78 path_names = os.path.join(self.output.log_dir, file_type)79 for old_path_name in glob.glob(path_names):80 new_path_name = '.'.join([old_path_name, 'old'])81 os.rename(old_path_name, new_path_name)82 def _is_robot_mode(self):83 return self.robot.is_robot_action_mode() or self.mode == MODE.ROBOT_SIM84 def _get_gesture_names(self):85 """Determine the gesture names based on the mode."""86 if self.mode == MODE.QUICKSTEP:87 return conf.gesture_names_quickstep88 elif self.mode == MODE.NOISE:89 return conf.gesture_names_noise_extended90 elif self._is_robot_mode():91 # The mode could be MODE.ROBOT or MODE.ROBOT_SIM.92 # The same gesture names list is used in both modes.93 return conf.gesture_names_robot[self.device_type]94 elif self.mode == MODE.MANUAL:95 # Define the manual list which is gesture_names_complete:96 # gesture_names_robot - gesture_names_equipment_required97 manual_set = (set(conf.gesture_names_complete[self.device_type]) -98 set(conf.gesture_names_robot[self.device_type]))99 return list(manual_set - set(conf.gesture_names_fngenerator_required))100 elif self.mode == MODE.CALIBRATION:101 return conf.gesture_names_calibration102 else:103 # Filter out tests that need a function generator for COMPLETE mode104 # unless they've indicated that they have one105 return [n for n in conf.gesture_names_complete[self.device_type]106 if (self.fngenerator_only or107 n not in conf.gesture_names_fngenerator_required)]108 def _non_blocking_open(self, filename):109 """Open the file in non-blocing mode."""110 fd = open(filename)111 fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)112 return fd113 def _non_blocking_read(self, dev, fd):114 """Non-blocking read on fd."""115 try:116 dev.read(fd)117 event = (dev.tv_sec, dev.tv_usec, dev.type, dev.code, dev.value)118 except Exception, e:119 event = None120 return event121 def _reopen_system_device(self):122 """Close the device and open a new one."""123 self.system_device.close()124 self.system_device = open(self.device_node)125 self.system_device = self._non_blocking_open(self.device_node)126 def _set_static_prompt_messages(self):127 """Set static prompt messages."""128 # Prompt for next gesture.129 self._prompt_next = (130 "Press SPACE to save this file and go to next test,\n"131 " 'm' to save this file and record again,\n"132 " 'd' to delete this file and try again,\n"133 " 'x' to discard this file and exit.")134 # Prompt to see test result through timeout callback.135 self._prompt_result = (136 "Perform the gesture now.\n"137 "See the test result on the right after finger lifted.\n"138 "Or press 'x' to exit.")139 def _get_prompt_abnormal_gestures(self, warn_msg):140 """Prompt for next gesture."""141 prompt = '\n'.join(142 ["It is very likely that you perform a WRONG gesture!",143 warn_msg,144 "Press 'd' to delete this file and try again (recommended),",145 " SPACE to save this file if you are sure it's correct,",146 " 'x' to discard this file and exit."])147 return prompt148 def _get_prompt_no_data(self):149 """Prompt to remind user of performing gestures."""150 prompt = ("You need to perform the specified gestures "151 "before pressing SPACE.\n")152 return prompt + self._prompt_result153 def _get_record_cmd(self):154 """Get the device event record command."""155 # Run mtplot with settings to disable clearing the display if the robot156 # clicks the pad, and adding a visible click indicator in the output157 self.record_program = 'mtplot -s1 -c0 -m0'158 if not common_util.program_exists(self.record_program):159 msg = 'Error: the program "%s" does not exist in $PATH.'160 self.output.print_report(msg % self.record_program)161 exit(1)162 display_name = firmware_utils.get_display_name()163 self.geometry_str = '%dx%d+%d+%d' % self.device_geometry164 format_str = '%s %s -d %s -g %s'165 self.record_cmd = format_str % (self.record_program,166 self.device_node,167 display_name,168 self.geometry_str)169 self.output.print_report('Record program: %s' % self.record_cmd)170 def _span_seq(self, seq1, seq2):171 """Span sequence seq1 over sequence seq2.172 E.g., seq1 = (('a', 'b'), 'c')173 seq2 = ('1', ('2', '3'))174 res = (('a', 'b', '1'), ('a', 'b', '2', '3'),175 ('c', '1'), ('c', '2', '3'))176 E.g., seq1 = ('a', 'b')177 seq2 = ('1', '2', '3')178 res = (('a', '1'), ('a', '2'), ('a', '3'),179 ('b', '1'), ('b', '2'), ('b', '3'))180 E.g., seq1 = (('a', 'b'), ('c', 'd'))181 seq2 = ('1', '2', '3')182 res = (('a', 'b', '1'), ('a', 'b', '2'), ('a', 'b', '3'),183 ('c', 'd', '1'), ('c', 'd', '2'), ('c', 'd', '3'))184 """185 to_list = lambda s: list(s) if isinstance(s, tuple) else [s]186 return tuple(tuple(to_list(s1) + to_list(s2)) for s1 in seq1187 for s2 in seq2)188 def span_variations(self, seq):189 """Span the variations of a gesture."""190 if seq is None:191 return (None,)192 elif isinstance(seq[0], tuple):193 return reduce(self._span_seq, seq)194 else:195 return seq196 def _stop(self):197 """Terminate the recording process."""198 self.record_proc.poll()199 # Terminate the process only when it was not terminated yet.200 if self.record_proc.returncode is None:201 self.record_proc.terminate()202 self.record_proc.wait()203 self.output.print_window('')204 def _get_gesture_image_name(self):205 """Get the gesture file base name without file extension."""206 filepath = os.path.splitext(self.gesture_file_name)[0]207 self.gesture_image_name = filepath + '.png'208 return filepath209 def _close_gesture_file(self):210 """Close the gesture file."""211 if self.gesture_file.closed:212 return213 filename = self.gesture_file.name214 self.gesture_file.close()215 # Strip off the header of the gesture file.216 #217 # Input driver version is 1.0.1218 # Input device ID: bus 0x18 vendor 0x0 product 0x0 version 0x0219 # Input device name: "Atmel maXTouch Touchpad"220 # ...221 # Testing ... (interrupt to exit)222 # Event: time 519.855, type 3 (EV_ABS), code 57 (ABS_MT_TRACKING_ID),223 # value 884224 #225 tmp_filename = filename + '.tmp'226 os.rename(filename, tmp_filename)227 with open(tmp_filename) as src_f:228 with open(filename, 'w') as dst_f:229 for line in src_f:230 if line.startswith('Event:'):231 dst_f.write(line)232 os.remove(tmp_filename)233 def _stop_record_and_post_image(self):234 """Terminate the recording process."""235 if self.record_new_file:236 self._close_gesture_file()237 self.screen_shot.dump_root(self._get_gesture_image_name())238 self.record_proc.terminate()239 self.record_proc.wait()240 else:241 self._get_gesture_image_name()242 self.win.set_image(self.gesture_image_name)243 def _create_prompt(self, test, variation):244 """Create a color prompt."""245 prompt = test.prompt246 if isinstance(variation, tuple):247 subprompt = reduce(lambda s1, s2: s1 + s2,248 tuple(test.subprompt[s] for s in variation))249 elif variation is None or test.subprompt is None:250 subprompt = None251 else:252 subprompt = test.subprompt[variation]253 if subprompt is None:254 color_prompt = prompt255 monochrome_prompt = prompt256 else:257 color_prompt = mini_color.color_string(prompt, '{', '}', 'green')258 color_prompt = color_prompt.format(*subprompt)259 monochrome_prompt = prompt.format(*subprompt)260 color_msg_format = mini_color.color_string('\n<%s>:\n%s%s', '<', '>',261 'blue')262 color_msg = color_msg_format % (test.name, self.prefix_space,263 color_prompt)264 msg = '%s: %s' % (test.name, monochrome_prompt)265 glog = firmware_log.GestureLog()266 glog.name = test.name267 glog.variation = variation268 glog.prompt = monochrome_prompt269 return (msg, color_msg, glog)270 def _choice_exit(self):271 """Procedure to exit."""272 self._stop()273 if os.path.exists(self.gesture_file_name):274 os.remove(self.gesture_file_name)275 self.output.print_report(self.deleted_msg)276 def _stop_record_and_rm_file(self):277 """Stop recording process and remove the current gesture file."""278 self._stop()279 if os.path.exists(self.gesture_file_name):280 os.remove(self.gesture_file_name)281 self.output.print_report(self.deleted_msg)282 def _create_gesture_file_name(self, gesture, variation):283 """Create the gesture file name based on its variation.284 Examples of different levels of file naming:285 Primary name:286 pinch_to_zoom.zoom_in-lumpy-fw_11.27287 Root name:288 pinch_to_zoom.zoom_in-lumpy-fw_11.27-manual-20130221_050510289 Base name:290 pinch_to_zoom.zoom_in-lumpy-fw_11.27-manual-20130221_050510.dat291 """292 if variation is None:293 gesture_name = gesture.name294 else:295 if type(variation) is tuple:296 name_list = [gesture.name,] + list(variation)297 else:298 name_list = [gesture.name, variation]299 gesture_name = '.'.join(name_list)300 self.primary_name = conf.filename.sep.join([301 gesture_name,302 self.board,303 conf.fw_prefix + self.firmware_version])304 root_name = conf.filename.sep.join([305 self.primary_name,306 self.mode,307 firmware_utils.get_current_time_str()])308 basename = '.'.join([root_name, conf.filename.ext])309 return basename310 def _add_scores(self, new_scores):311 """Add the new scores of a single gesture to the scores list."""312 if new_scores is not None:313 self.scores += new_scores314 def _final_scores(self, scores):315 """Print the final score."""316 # Note: conf.score_aggregator uses a function in fuzzy module.317 final_score = eval(conf.score_aggregator)(scores)318 self.output.print_report('\nFinal score: %s\n' % str(final_score))319 def _robot_action(self):320 """Control the robot to perform the action."""321 if self._is_robot_mode() or self.robot.is_manual_noise_test_mode():322 self.robot.configure_noise(self.gesture, self.variation)323 if self._is_robot_mode():324 self.robot.control(self.gesture, self.variation)325 # Once the script terminates start a timeout to clean up if one326 # hasn't already been set to keep the test suite from hanging.327 if not self.gesture_begins_flag:328 self.win.register_timeout_add(self.gesture_timeout_callback,329 self.gesture.timeout)330 def _handle_user_choice_save_after_parsing(self, next_gesture=True):331 """Handle user choice for saving the parsed gesture file."""332 self.output.print_window('')333 if self.use_existent_event_file_flag or self.recording:334 if self.saved_msg:335 self.output.print_report(self.saved_msg)336 if self.new_scores:337 self._add_scores(self.new_scores)338 self.output.report_html.insert_image(self.gesture_image_name)339 self.output.report_html.flush()340 # After flushing to report_html, reset the gesture_image_name so that341 # it will not be reused by next gesture variation accidentally.342 self.gesture_image_name = None343 if self._pre_setup_this_gesture_variation(next_gesture=next_gesture):344 # There are more gestures.345 self._setup_this_gesture_variation()346 self._robot_action()347 else:348 # No more gesture.349 self._final_scores(self.scores)350 self.output.stop()351 self.output.report_html.stop()352 self.win.stop()353 self.packets = None354 def _handle_user_choice_discard_after_parsing(self):355 """Handle user choice for discarding the parsed gesture file."""356 self.output.print_window('')357 self._setup_this_gesture_variation()358 self._robot_action()359 self.packets = None360 def _handle_user_choice_exit_after_parsing(self):361 """Handle user choice to exit after the gesture file is parsed."""362 self._stop_record_and_rm_file()363 self.output.stop()364 self.output.report_html.stop()365 self.win.stop()366 def check_for_wrong_number_of_fingers(self, details):367 flag_found = False368 try:369 position = details.index('CountTrackingIDValidator')370 except ValueError as e:371 return None372 # An example of the count of tracking IDs:373 # ' count of trackid IDs: 1'374 number_tracking_ids = int(details[position + 1].split()[-1])375 # An example of the criteria_str looks like:376 # ' criteria_str: == 2'377 criteria = int(details[position + 2].split()[-1])378 if number_tracking_ids < criteria:379 print ' CountTrackingIDValidator: '380 print ' number_tracking_ids: ', number_tracking_ids381 print ' criteria: ', criteria382 print ' number_tracking_ids should be larger!'383 msg = 'Number of Tracking IDs should be %d instead of %d'384 return msg % (criteria, number_tracking_ids)385 return None386 def _empty_packets_is_legal_result(self):387 return ('tap' in self.gesture.name and self._is_robot_mode())388 def _handle_user_choice_validate_before_parsing(self):389 """Handle user choice for validating before gesture file is parsed."""390 # Parse the device events. Make sure there are events.391 self.packets = self.parser.parse_file(self.gesture_file_name)392 if self.packets or self._empty_packets_is_legal_result():393 # Validate this gesture and get the results.394 (self.new_scores, msg_list, vlogs) = validators.validate(395 self.packets, self.gesture, self.variation)396 # If the number of tracking IDs is less than the expected value,397 # the user probably made a wrong gesture.398 error = self.check_for_wrong_number_of_fingers(msg_list)399 if error:400 prompt = self._get_prompt_abnormal_gestures(error)401 color = 'red'402 else:403 prompt = self._prompt_next404 color = 'black'405 self.output.print_window(msg_list)406 self.output.buffer_report(msg_list)407 self.output.report_html.insert_validator_logs(vlogs)408 self.win.set_prompt(prompt, color=color)409 print prompt410 self._stop_record_and_post_image()411 else:412 self.win.set_prompt(self._get_prompt_no_data(), color='red')413 def _handle_user_choice_exit_before_parsing(self):414 """Handle user choice to exit before the gesture file is parsed."""415 self._close_gesture_file()416 self._handle_user_choice_exit_after_parsing()417 def _is_parsing_gesture_file_done(self):418 """Is parsing the gesture file done?"""419 return self.packets is not None420 def _is_arrow_key(self, choice):421 """Is this an arrow key?"""422 return (choice in TFK.ARROW_KEY_LIST)423 def user_choice_callback(self, fd, condition):424 """A callback to handle the key pressed by the user.425 This is the primary GUI event-driven method handling the user input.426 """427 choice = self.keyboard.get_key_press_event(fd)428 if choice:429 self._handle_keyboard_event(choice)430 return True431 def _handle_keyboard_event(self, choice):432 """Handle the keyboard event."""433 if self._is_arrow_key(choice):434 self.win.scroll(choice)435 elif self.robot_waiting:436 # The user wants the robot to start its action.437 if choice in (TFK.SAVE, TFK.SAVE2):438 self.robot_waiting = False439 self._robot_action()440 # The user wants to exit.441 elif choice == TFK.EXIT:442 self._handle_user_choice_exit_after_parsing()443 elif self._is_parsing_gesture_file_done():444 # Save this gesture file and go to next gesture.445 if choice in (TFK.SAVE, TFK.SAVE2):446 self._handle_user_choice_save_after_parsing()447 # Save this file and perform the same gesture again.448 elif choice == TFK.MORE:449 self._handle_user_choice_save_after_parsing(next_gesture=False)450 # Discard this file and perform the gesture again.451 elif choice == TFK.DISCARD:452 self._handle_user_choice_discard_after_parsing()453 # The user wants to exit.454 elif choice == TFK.EXIT:455 self._handle_user_choice_exit_after_parsing()456 # The user presses any wrong key.457 else:458 self.win.set_prompt(self._prompt_next, color='red')459 else:460 if choice == TFK.EXIT:461 self._handle_user_choice_exit_before_parsing()462 # The user presses any wrong key.463 else:464 self.win.set_prompt(self._prompt_result, color='red')465 def _get_all_gesture_variations(self, simplified):466 """Get all variations for all gestures."""467 gesture_variations_list = []468 self.variations_dict = {}469 for gesture in self.gesture_list:470 variations_list = []471 variations = self.span_variations(gesture.variations)472 for variation in variations:473 gesture_variations_list.append((gesture, variation))474 variations_list.append(variation)475 if simplified:476 break477 self.variations_dict[gesture.name] = variations_list478 self.gesture_variations = iter(gesture_variations_list)479 def gesture_timeout_callback(self):480 """A callback watching whether a gesture has timed out."""481 if self.replay_dir:482 # There are event files to replay for this gesture variation.483 if self.use_existent_event_file_flag:484 self._handle_user_choice_validate_before_parsing()485 self._handle_user_choice_save_after_parsing(next_gesture=True)486 return False487 # A gesture is stopped only when two conditions are met simultaneously:488 # (1) there are no reported packets for a timeout interval, and489 # (2) the number of tracking IDs is 0.490 elif (self.gesture_continues_flag or491 not self.mtb_evemu.all_fingers_leaving()):492 self.gesture_continues_flag = False493 return True494 else:495 self._handle_user_choice_validate_before_parsing()496 self.win.remove_event_source(self.gesture_file_watch_tag)497 if self._is_robot_mode():498 self._handle_keyboard_event(TFK.SAVE)499 return False500 def gesture_file_watch_callback(self, fd, condition, evdev_device):501 """A callback to watch the device input."""502 # Read the device node continuously until end503 event = True504 while event:505 event = self._non_blocking_read(evdev_device, fd)506 if event:507 self.mtb_evemu.process_event(event)508 self.gesture_continues_flag = True509 if (not self.gesture_begins_flag):510 self.gesture_begins_flag = True511 self.win.register_timeout_add(self.gesture_timeout_callback,512 self.gesture.timeout)513 return True514 def init_gesture_setup_callback(self, widget, event):515 """A callback to set up environment before a user starts a gesture."""516 if not self.init_flag:517 self.init_flag = True518 self._pre_setup_this_gesture_variation()519 self._setup_this_gesture_variation()520 self._robot_action()521 def _get_existent_event_files(self):522 """Get the existent event files that starts with the primary_name."""523 primary_pathnames = os.path.join(self.output.log_dir,524 self.primary_name + '*.dat')525 self.primary_gesture_files = glob.glob(primary_pathnames)526 # Reverse sorting the file list so that we could pop from the tail.527 self.primary_gesture_files.sort()528 self.primary_gesture_files.reverse()529 def _use_existent_event_file(self):530 """If the replay flag is set in the command line, and there exists a531 file(s) with the same primary name, then use the existent file(s)532 instead of recording a new one.533 """534 if self.primary_gesture_files:535 self.gesture_file_name = self.primary_gesture_files.pop()536 return True537 return False538 def _pre_setup_this_gesture_variation(self, next_gesture=True):539 """Get gesture, variation, filename, prompt, etc."""540 next_gesture_first_time = False541 if next_gesture:542 if self.gv_count < self.iterations:543 self.gv_count += 1544 else:545 self.gv_count = 1546 gesture_variation = next(self.gesture_variations, None)547 if gesture_variation is None:548 return False549 self.gesture, self.variation = gesture_variation550 next_gesture_first_time = True551 basename = self._create_gesture_file_name(self.gesture, self.variation)552 if next_gesture_first_time:553 self._get_existent_event_files()554 if self.replay_dir or self.resume_dir:555 self.use_existent_event_file_flag = self._use_existent_event_file()556 if ((not self.replay_dir and not self.resume_dir) or557 (self.resume_dir and not self.use_existent_event_file_flag)):558 self.gesture_file_name = os.path.join(self.output.log_dir, basename)559 self.saved_msg = '(saved: %s)\n' % self.gesture_file_name560 self.deleted_msg = '(deleted: %s)\n' % self.gesture_file_name561 else:562 self.saved_msg = None563 self.deleted_msg = None564 self.new_scores = None565 if self.robot.is_robot_action_mode() or self.robot.is_manual_noise_test_mode():566 self.robot.turn_off_noise()567 (msg, color_msg, glog) = self._create_prompt(self.gesture,568 self.variation)569 self.win.set_gesture_name(msg)570 self.output.report_html.insert_gesture_log(glog)571 print color_msg572 self.output.print_report(color_msg)573 return True574 def _setup_this_gesture_variation(self):575 """Set up the recording process or use an existent event data file."""576 if self.replay_dir:577 self.record_new_file = False578 self.win.register_timeout_add(self.gesture_timeout_callback, 0)579 return580 if self.resume_dir and self.use_existent_event_file_flag:581 self.record_new_file = False582 self._handle_user_choice_validate_before_parsing()583 self._handle_keyboard_event(TFK.SAVE)584 return585 # Initiate the MtbSanityValidator. Note that this should be done each586 # time just before recording the gesture file since it requires a587 # snapshot of the input device before any finger touching the device.588 self.gesture.mtb_sanity_validator = validators.MtbSanityValidator()589 # Now, we will record a new gesture event file.590 # Fork a new process for mtplot. Add io watch for the gesture file.591 self.record_new_file = True592 self.gesture_file = open(self.gesture_file_name, 'w')593 self.record_proc = subprocess.Popen(self.record_cmd.split(),594 stdout=self.gesture_file)595 # Watch if data come in to the monitored file.596 self.gesture_begins_flag = False597 self._reopen_system_device()598 self.gesture_file_watch_tag = self.win.register_io_add_watch(599 self.gesture_file_watch_callback, self.system_device,...
gesture.py
Source:gesture.py
...9 g.add_stroke(point_list=[(1,1), (3,4), (2,1)])10 g.normalize()11 # Add it to the database12 gdb = GestureDatabase()13 gdb.add_gesture(g)14 # And for the next gesture, try to find it!15 g2 = Gesture()16 # ...17 gdb.find(g2)18.. warning::19 You don't really want to do this: it's more of an example of how20 to construct gestures dynamically. Typically, you would21 need a lot more points, so it's better to record gestures in a file and22 reload them to compare later. Look in the examples/gestures directory for23 an example of how to do that.24'''25__all__ = ('Gesture', 'GestureDatabase', 'GesturePoint', 'GestureStroke')26import pickle27import base6428import zlib29import math30from kivy.vector import Vector31from io import BytesIO32class GestureDatabase(object):33 '''Class to handle a gesture database.'''34 def __init__(self):35 self.db = []36 def add_gesture(self, gesture):37 '''Add a new gesture to the database.'''38 self.db.append(gesture)39 def find(self, gesture, minscore=0.9, rotation_invariant=True):40 '''Find a matching gesture in the database.'''41 if not gesture:42 return43 best = None44 bestscore = minscore45 for g in self.db:46 score = g.get_score(gesture, rotation_invariant)47 if score < bestscore:48 continue49 bestscore = score50 best = g51 if not best:52 return53 return (bestscore, best)54 def gesture_to_str(self, gesture):55 '''Convert a gesture into a unique string.'''56 io = BytesIO()57 p = pickle.Pickler(io)58 p.dump(gesture)59 data = base64.b64encode(zlib.compress(io.getvalue(), 9))60 return data61 def str_to_gesture(self, data):62 '''Convert a unique string to a gesture.'''63 io = BytesIO(zlib.decompress(base64.b64decode(data)))64 p = pickle.Unpickler(io)65 gesture = p.load()66 return gesture67class GesturePoint:68 def __init__(self, x, y):69 '''Stores the x,y coordinates of a point in the gesture.'''70 self.x = float(x)71 self.y = float(y)72 def scale(self, factor):73 ''' Scales the point by the given factor.'''74 self.x *= factor75 self.y *= factor76 return self77 def __repr__(self):78 return 'Mouse_point: %f,%f' % (self.x, self.y)79class GestureStroke:80 ''' Gestures can be made up of multiple strokes.'''81 def __init__(self):82 ''' A stroke in the gesture.'''83 self.points = list()84 self.screenpoints = list()85 # These return the min and max coordinates of the stroke86 @property87 def max_x(self):88 if len(self.points) == 0:89 return 090 return max(self.points, key=lambda pt: pt.x).x91 @property92 def min_x(self):93 if len(self.points) == 0:94 return 095 return min(self.points, key=lambda pt: pt.x).x96 @property97 def max_y(self):98 if len(self.points) == 0:99 return 0100 return max(self.points, key=lambda pt: pt.y).y101 @property102 def min_y(self):103 if len(self.points) == 0:104 return 0105 return min(self.points, key=lambda pt: pt.y).y106 def add_point(self, x, y):107 '''108 add_point(x=x_pos, y=y_pos)109 Adds a point to the stroke.110 '''111 self.points.append(GesturePoint(x, y))112 self.screenpoints.append((x, y))113 def scale_stroke(self, scale_factor):114 '''115 scale_stroke(scale_factor=float)116 Scales the stroke down by scale_factor.117 '''118 self.points = [pt.scale(scale_factor) for pt in self.points]119 def points_distance(self, point1, point2):120 '''121 points_distance(point1=GesturePoint, point2=GesturePoint)122 Returns the distance between two GesturePoints.123 '''124 x = point1.x - point2.x125 y = point1.y - point2.y126 return math.sqrt(x * x + y * y)127 def stroke_length(self, point_list=None):128 '''Finds the length of the stroke. If a point list is given,129 finds the length of that list.130 '''131 if point_list is None:132 point_list = self.points133 gesture_length = 0.0134 if len(point_list) <= 1: # If there is only one point -> no length135 return gesture_length136 for i in range(len(point_list) - 1):137 gesture_length += self.points_distance(138 point_list[i], point_list[i + 1])139 return gesture_length140 def normalize_stroke(self, sample_points=32):141 '''Normalizes strokes so that every stroke has a standard number of142 points. Returns True if stroke is normalized, False if it can't be143 normalized. sample_points controls the resolution of the stroke.144 '''145 # If there is only one point or the length is 0, don't normalize146 if len(self.points) <= 1 or self.stroke_length(self.points) == 0.0:147 return False148 # Calculate how long each point should be in the stroke149 target_stroke_size = \150 self.stroke_length(self.points) / float(sample_points)151 new_points = list()152 new_points.append(self.points[0])153 # We loop on the points154 prev = self.points[0]155 src_distance = 0.0156 dst_distance = target_stroke_size157 for curr in self.points[1:]:158 d = self.points_distance(prev, curr)159 if d > 0:160 prev = curr161 src_distance = src_distance + d162 # The new point need to be inserted into the163 # segment [prev, curr]164 while dst_distance < src_distance:165 x_dir = curr.x - prev.x166 y_dir = curr.y - prev.y167 ratio = (src_distance - dst_distance) / d168 to_x = x_dir * ratio + prev.x169 to_y = y_dir * ratio + prev.y170 new_points.append(GesturePoint(to_x, to_y))171 dst_distance = self.stroke_length(self.points) / \172 float(sample_points) * len(new_points)173 # If this happens, we are into troubles...174 if not len(new_points) == sample_points:175 raise ValueError('Invalid number of strokes points; got '176 '%d while it should be %d' %177 (len(new_points), sample_points))178 self.points = new_points179 return True180 def center_stroke(self, offset_x, offset_y):181 '''Centers the stroke by offsetting the points.'''182 for point in self.points:183 point.x -= offset_x184 point.y -= offset_y185class Gesture:186 '''A python implementation of a gesture recognition algorithm by187 Oleg Dopertchouk: http://www.gamedev.net/reference/articles/article2039.asp188 Implemented by Jeiel Aranal (chemikhazi@gmail.com),189 released into the public domain.190 '''191 # Tolerance for evaluation using the '==' operator192 DEFAULT_TOLERANCE = 0.1193 def __init__(self, tolerance=None):194 '''195 Gesture([tolerance=float])196 Creates a new gesture with an optional matching tolerance value.197 '''198 self.width = 0.199 self.height = 0.200 self.gesture_product = 0.201 self.strokes = list()202 if tolerance is None:203 self.tolerance = Gesture.DEFAULT_TOLERANCE204 else:205 self.tolerance = tolerance206 def _scale_gesture(self):207 ''' Scales down the gesture to a unit of 1.'''208 # map() creates a list of min/max coordinates of the strokes209 # in the gesture and min()/max() pulls the lowest/highest value210 min_x = min([stroke.min_x for stroke in self.strokes])211 max_x = max([stroke.max_x for stroke in self.strokes])212 min_y = min([stroke.min_y for stroke in self.strokes])213 max_y = max([stroke.max_y for stroke in self.strokes])214 x_len = max_x - min_x215 self.width = x_len216 y_len = max_y - min_y217 self.height = y_len218 scale_factor = max(x_len, y_len)219 if scale_factor <= 0.0:220 return False221 scale_factor = 1.0 / scale_factor222 for stroke in self.strokes:223 stroke.scale_stroke(scale_factor)224 return True225 def _center_gesture(self):226 ''' Centers the Gesture.points of the gesture.'''227 total_x = 0.0228 total_y = 0.0229 total_points = 0230 for stroke in self.strokes:231 # adds up all the points inside the stroke232 stroke_y = sum([pt.y for pt in stroke.points])233 stroke_x = sum([pt.x for pt in stroke.points])234 total_y += stroke_y235 total_x += stroke_x236 total_points += len(stroke.points)237 if total_points == 0:238 return False239 # Average to get the offset240 total_x /= total_points241 total_y /= total_points242 # Apply the offset to the strokes243 for stroke in self.strokes:244 stroke.center_stroke(total_x, total_y)245 return True246 def add_stroke(self, point_list=None):247 '''Adds a stroke to the gesture and returns the Stroke instance.248 Optional point_list argument is a list of the mouse points for249 the stroke.250 '''251 self.strokes.append(GestureStroke())252 if isinstance(point_list, list) or isinstance(point_list, tuple):253 for point in point_list:254 if isinstance(point, GesturePoint):255 self.strokes[-1].points.append(point)256 elif isinstance(point, list) or isinstance(point, tuple):257 if len(point) != 2:258 raise ValueError("Stroke entry must have 2 values max")259 self.strokes[-1].add_point(point[0], point[1])260 else:261 raise TypeError("The point list should either be "262 "tuples of x and y or a list of "263 "GesturePoint objects")264 elif point_list is not None:265 raise ValueError("point_list should be a tuple/list")266 return self.strokes[-1]267 def normalize(self, stroke_samples=32):268 '''Runs the gesture normalization algorithm and calculates the dot269 product with self.270 '''271 if not self._scale_gesture() or not self._center_gesture():272 self.gesture_product = False273 return False274 for stroke in self.strokes:275 stroke.normalize_stroke(stroke_samples)276 self.gesture_product = self.dot_product(self)277 def get_rigid_rotation(self, dstpts):278 '''279 Extract the rotation to apply to a group of points to minimize the280 distance to a second group of points. The two groups of points are281 assumed to be centered. This is a simple version that just picks282 an angle based on the first point of the gesture.283 '''284 if len(self.strokes) < 1 or len(self.strokes[0].points) < 1:285 return 0...
gestures.py
Source:gestures.py
1"""Gesture detection for SNAP Badge, using the LIS3DH accelerometer.2Note: this could be enhanced to use the LIS3D hardware for detection, with the advantage of much lower3 cpu utilization and better performance including wake on interrupt. The initial software based4 implementation has the advantage of being easy to understand and experiment with.5"""6from drivers.lis3dh_accel import *7# Detected gestures8GESTURE_DOWN = 0 # Badge held vertical, then flipped down face-up9GESTURE_ZERO_G = 1 # Badge experienced zero-g condition10GESTURE_HIGH_G = 2 # Badge experienced high-g condition11# Double tap configuration parameters 12DT_CFG1 = 0x77 # ODR = 400Hz13DT_CFG2 = 0x84 # Enable High-pass filter14DT_CFG3 = 0xc0 # Set INT1 pin15DT_SRC = 0x2016DT_THRESHOLD = 0x5017DT_CFG = 0x2018DT_LIMIT = 0x17 # 57.5ms19DT_LATENCY = 0x25 # 92.5ms20DT_WINDOW = 0x30 # 120ms21gesture_debounce = 2022gesture_cb = None23def gesture_set_callback(cb):24 """Set callback when gesture detected. Callback receives detected gesture type as parameter.25 ex: def my_gestures(gesture_type): ...26 """27 global gesture_cb28 gesture_cb = cb29def gesture_update_accel():30 """Track accelerometer position readings from last poll. Enables determining inertial 'diffs' of each axis"""31 global gest_last_x, gest_last_y, gest_last_z32 gest_last_x = lis_axis_x33 gest_last_y = lis_axis_y34 gest_last_z = lis_axis_z35def gesture_poll_10ms():36 """Called by system every 10ms"""37 global gesture_debounce38 # Poll the accelerometer39 lis_read()40 41 # Debounce gesture detection42 if gesture_debounce:43 gesture_debounce -= 144 else:45 #print lis_axis_x, ",", lis_axis_y, ",", lis_axis_z46 #print "dxyz=", lis_axis_x - rps_last_x, ",",lis_axis_y - rps_last_y, ",",lis_axis_z - rps_last_z47 48 # Detect GESTURE_DOWN event49 dz = lis_axis_z - gest_last_z50 if dz > 6000:51 if gesture_cb:52 gesture_cb(GESTURE_DOWN)53 gesture_debounce = 2054 55 gesture_update_accel()56 57def gesture_set_zero_g():58 """Configure accelerometer to detect zero-g condition and set interrupt"""59 lis_int1(0x95, 0x10, 0x10)60 61def gesture_set_high_g():62 """Configure accelerometer to detect high-g condition and set interrupt"""63 lis_int1(0x2a, 0x30, 0x00)64 65def gesture_set_double_tap():66 """Configure accelerometer to detect double tap and set interrupt"""67 lis_ctrl(1, DT_CFG1)68 lis_ctrl(2, DT_CFG2)69 lis_ctrl(3, DT_CFG3)70 lis_tap_cfg(DT_SRC, DT_THRESHOLD, DT_CFG, DT_LIMIT, DT_LATENCY, DT_WINDOW)...
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run uiautomator automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
