U Pe@sdZdZddlZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZmZddl mZmZddlmZdd lmZdd lmZdd lmZdd lm Z dd l!m"Z"e se#Z$dZ%dZ&dZ'eddZ(Gddde)Z*GdddeZ+GdddeZ,Gddde-Z.Gddde-Z/Gddde-Z0ddZ1dd Z2d!d"Z3d#d$Z4d%d&Z5d'd(Z6d)d*Z7d+d,Z8d-d.Z9d/d0Z:d1d2Z;dS)3a\ Multistroke gesture recognizer ============================== .. versionadded:: 1.9.0 .. warning:: This is experimental and subject to change as long as this warning notice is present. See :file:`kivy/examples/demo/multistroke/main.py` for a complete application example. Conceptual Overview ------------------- This module implements the Protractor gesture recognition algorithm. :class:`Recognizer` is the search/database API similar to :class:`~kivy.gesture.GestureDatabase`. It maintains a list of :class:`MultistrokeGesture` objects and allows you to search for a user-input gestures among them. :class:`ProgressTracker` tracks the progress of a :meth:`Recognizer.recognize` call. It can be used to interact with the running recognizer task, for example forcing it to stop half-way, or analyzing results as they arrive. :class:`MultistrokeGesture` represents a gesture in the gesture database (:attr:`Recognizer.db`). It is a container for :class:`UnistrokeTemplate` objects, and implements the heap permute algorithm to automatically generate all possible stroke orders (if desired). :class:`UnistrokeTemplate` represents a single stroke path. It's typically instantiated automatically by :class:`MultistrokeGesture`, but sometimes you may need to create them manually. :class:`Candidate` represents a user-input gesture that is used to search the gesture database for matches. It is normally instantiated automatically by calling :meth:`Recognizer.recognize`. Usage examples -------------- See :file:`kivy/examples/demo/multistroke/main.py` for a complete application example. You can bind to events on :class:`Recognizer` to track the state of all calls to :meth:`Recognizer.recognize`. The callback function will receive an instance of :class:`ProgressTracker` that can be used to analyze and control various aspects of the recognition process :: from kivy.vector import Vector from kivy.multistroke import Recognizer gdb = Recognizer() def search_start(gdb, pt): print("A search is starting with %d tasks" % (pt.tasks)) def search_stop(gdb, pt): # This will call max() on the result dictionary, so it's best to store # it instead of calling it 3 times consecutively best = pt.best print("Search ended (%s). Best is %s (score %f, distance %f)" % ( pt.status, best['name'], best['score'], best['dist'] )) # Bind your callbacks to track all matching operations gdb.bind(on_search_start=search_start) gdb.bind(on_search_complete=search_stop) # The format below is referred to as `strokes`, a list of stroke paths. # Note that each path shown here consists of two points, ie a straight # line; if you plot them it looks like a T, hence the name. gdb.add_gesture('T', [ [Vector(30, 7), Vector(103, 7)], [Vector(66, 7), Vector(66, 87)]]) # Now you can search for the 'T' gesture using similar data (user input). # This will trigger both of the callbacks bound above. gdb.recognize([ [Vector(45, 8), Vector(110, 12)], [Vector(88, 9), Vector(85, 95)]]) On the next :class:`~kivy.clock.Clock` tick, the matching process starts (and, in this case, completes). To track individual calls to :meth:`Recognizer.recognize`, use the return value (also a :class:`ProgressTracker` instance) :: # Same as above, but keep track of progress using returned value progress = gdb.recognize([ [Vector(45, 8), Vector(110, 12)], [Vector(88, 9), Vector(85, 95)]]) progress.bind(on_progress=my_other_callback) print(progress.progress) # = 0 # [ assuming a kivy.clock.Clock.tick() here ] print(result.progress) # = 1 Algorithm details ----------------- For more information about the matching algorithm, see: "Protractor: A fast and accurate gesture recognizer" by Yang Li http://yangl.org/pdf/protractor-chi2010.pdf "$N-Protractor" by Lisa Anthony and Jacob O. Wobbrock http://depts.washington.edu/aimgroup/proj/dollar/ndollar-protractor.pdf Some of the code is derived from the JavaScript implementation here: http://depts.washington.edu/aimgroup/proj/dollar/ndollar.html ) RecognizerProgressTrackerMultistrokeGestureUnistrokeTemplate CandidateN)match)deque)sqrtpiradiansacosatanatan2powfloor)sincosVector)Clock)EventDispatcher) ListProperty)PY2)BytesIO g@o@g?c@s eZdZdS)MultistrokeErrorN)__name__ __module__ __qualname__rr4/tmp/pip-unpacked-wheel-xzebddm3/kivy/multistroke.pyrsrcseZdZdZegZfddZddZddZdd Z dd d Z dd dZ ddZ ddZ dddZddZddZddZZS)raQ:class:`Recognizer` provides a gesture database with matching facilities. :Events: `on_search_start` Fired when a new search is started using this Recognizer. `on_search_complete` Fired when a running search ends, for whatever reason. (use :data:`ProgressTracker.status` to find out) :Properties: `db` A :class:`ListProperty` that contains the available :class:`MultistrokeGesture` objects. :attr:`db` is a :class:`~kivy.properties.ListProperty` and defaults to [] c s*tt|jf||d|ddS)Non_search_starton_search_complete)superr__init__register_event_type)selfkwargs __class__rr r$s zRecognizer.__init__cKsd}|j}|dd}|dk r0d}t|ts0|g}|dd}d\}}|dk rvd}t|trb|\}}nt|trvd|}}|dd}|dk rd}t|ts|g}|dd} | dk rd}t| ts| g} |d d} | dk rd}|d d} | od} | dkod} |d dp |j}| s|r0| s0t|d d d}n|}t}|sN|||S|j}|D]}| dk rv| |j krvqX| r|j | krqX|rt |j |krqX|dk r|j |krqX|dk r|j |kr|S|r|D]"}t||jr||qqn||qX|S)a):meth:`filter` returns a subset of objects in :attr:`self.db`, according to given criteria. This is used by many other methods of the :class:`Recognizer`; the arguments below can for example be used when calling :meth:`Recognizer.recognize` or :meth:`Recognizer.export_gesture`. You normally don't need to call this directly. :Arguments: `name` Limits the returned list to gestures where :attr:`MultistrokeGesture.name` matches given regular expression(s). If re.match(name, MultistrokeGesture.name) tests true, the gesture is included in the returned list. Can be a string or an array of strings :: gdb = Recognizer() # Will match all names that start with a capital N # (ie Next, New, N, Nebraska etc, but not "n" or "next") gdb.filter(name='N') # exactly 'N' gdb.filter(name='N$') # Nebraska, teletubbies, France, fraggle, N, n, etc gdb.filter(name=['[Nn]', '(?i)T', '(?i)F']) `priority` Limits the returned list to gestures with certain :attr:`MultistrokeGesture.priority` values. If specified as an integer, only gestures with a lower priority are returned. If specified as a list (min/max) :: # Max priority 50 gdb.filter(priority=50) # Max priority 50 (same result as above) gdb.filter(priority=[0, 50]) # Min priority 50, max 100 gdb.filter(priority=[50, 100]) When this option is used, :attr:`Recognizer.db` is automatically sorted according to priority, incurring extra cost. You can use `force_priority_sort` to override this behavior if your gestures are already sorted according to priority. `orientation_sensitive` Limits the returned list to gestures that are orientation sensitive (True), gestures that are not orientation sensitive (False) or None (ignore template sensitivity, this is the default). `numstrokes` Limits the returned list to gestures that have the specified number of strokes (in :attr:`MultistrokeGesture.strokes`). Can be a single integer or a list of integers. `numpoints` Limits the returned list to gestures that have specific :attr:`MultistrokeGesture.numpoints` values. This is provided for flexibility, do not use it unless you understand what it does. Can be a single integer or a list of integers. `force_priority_sort` Can be used to override the default sort behavior. Normally :class:`MultistrokeGesture` objects are returned in priority order if the `priority` option is used. Setting this to True will return gestures sorted in priority order, False will return in the order gestures were added. None means decide automatically (the default). .. Note :: For improved performance, you can load your gesture database in priority order and set this to False when calling :meth:`Recognizer.recognize` `db` Can be set if you want to filter a different list of objects than :attr:`Recognizer.db`. You probably don't want to do this; it is used internally by :meth:`import_gesture`. FnameNTpriority)NN numstrokes numpointsorientation_sensitiveforce_priority_sortdbcSs|jSN)r+)nrrr 8z#Recognizer.filter..key)get isinstancelistintr0sortedrextendappendorientation_sensr-lenstrokesr+re_matchr*)r&r'Z have_filtersZ kwargs_getr*r+Zmin_pZmax_pr,r-r>r/Z force_sort_onZforce_sort_offr0tasklistoutZ out_appendgesturefrrr filtersxU                  zRecognizer.filtercKs(|sdS|jtf||d|dS)aSAdd a new gesture to the database. This will instantiate a new :class:`MultistrokeGesture` with `strokes` and append it to self.db. .. Note :: If you already have instantiated a :class:`MultistrokeGesture` object and wish to add it, append it to :attr:`Recognizer.db` manually. F)r*r@T)r0r=rr&r*r@r'rrr add_gesture_s zRecognizer.add_gesturecCsbttt|}t|}g}|j}|D],}|d}dd|D|d<|t f|q0|S)zParse data formatted by export_gesture(). Returns a list of :class:`MultistrokeGesture` objects. This is used internally by :meth:`import_gesture`, you normally don't need to call this directly.r@cSsg|]}dd|DqS)cSsg|]\}}t||qSrr).0xyrrr {s z7Recognizer.parse_gesture...rrIlinerrr rL{sz,Recognizer.parse_gesture..) rzlib decompressbase64 b64decodepickle Unpicklerr=loadr)r&dataiop multistrokesZ ms_append multistroker@rrr parse_gestureos   zRecognizer.parse_gestureNc Kst}tj|dd}g}dddddd}|}|jf|D]P}t|} d |ji} |D]} t|| | | <qVtd d |j D| d <| | q<| ||rt |d } | tt|d| ntt|dSdS)aExport a list of :class:`MultistrokeGesture` objects. Outputs a base64-encoded string that can be decoded to a Python list with the :meth:`parse_gesture` function or imported directly to :attr:`self.db` using :meth:`Recognizer.import_gesture`. If `filename` is specified, the output is written to disk, otherwise returned. This method accepts optional :meth:`Recognizer.filter` arguments. r)protocoldTF>@)r+r- stroke_sensr>angle_similarityr*css|]}dd|DVqdS)cSsg|]}|j|jfqSr)rJrK)rIrXrrr rLsz7Recognizer.export_gesture...NrrMrrr sz,Recognizer.export_gesture..r@wb N)rrSPicklerkeysrFdictr*getattrtupler@r=dumpopenwriterQ b64encoderOcompressgetvalueclose) r&filenamer'rWrXrYdefaultsZdkeysrZmattrrErrr export_gestures.       zRecognizer.export_gesturec Ksf|dk r(t|d}|}W5QRXn|dkr8td|jfd||i|}|rb|j|dS)aImport a list of gestures as formatted by :meth:`export_gesture`. One of `data` or `filename` must be specified. This method accepts optional :meth:`Recognizer.filter` arguments, if none are specified then all gestures in specified data are imported.Nrbz'import_gesture needs data= or filename=r0)rkreadrrFr[r0r<)r&rVrqr'infilenewrrr import_gestures zRecognizer.import_gesturecKsHt|drDt|jtrD|jf|}|rD|jd||jdd<dSdS)zTransfers :class:`MultistrokeGesture` objects from :attr:`Recognizer.db` to another :class:`Recognizer` instance `tgt`. This method accepts optional :meth:`Recognizer.filter` arguments. r0NT)hasattrr8r0r9rFr=)r&Ztgtr'sendrrr transfer_gestures   zRecognizer.transfer_gesturecKs8|jf|D]&}|D]}|d|j}||qq dS)aThis method is used to prepare :class:`UnistrokeTemplate` objects within the gestures in self.db. This is useful if you want to minimize punishment of lazy resampling by preparing all vectors in advance. If you do this before a call to :meth:`Recognizer.export_gesture`, you will have the vectors computed when you load the data later. This method accepts optional :meth:`Recognizer.filter` arguments. `force_numpoints`, if specified, will prepare all templates to the given number of points (instead of each template's preferred n; ie :data:`UnistrokeTemplate.numpoints`). You normally don't want to do this.force_numpointsN)rFr7r-prepare)r&r'rDtplr2rrr prepare_templatess zRecognizer.prepare_templatesrc sdtjf|tts`d_dfdd}t |S f dddsd n t d S) a% Search for gestures matching `strokes`. Returns a :class:`ProgressTracker` instance. This method accepts optional :meth:`Recognizer.filter` arguments. :Arguments: `strokes` A list of stroke paths (list of lists of :class:`~kivy.vector.Vector` objects) that will be matched against gestures in the database. Can also be a :class:`Candidate` instance. .. Warning :: If you manually supply a :class:`Candidate` that has a skip-flag, make sure that the correct filter arguments are set. Otherwise the system will attempt to load vectors that have not been computed. For example, if you set `skip_bounded` and do not set `orientation_sensitive` to False, it will raise an exception if an orientation_sensitive :class:`UnistrokeTemplate` is encountered. `goodscore` If this is set (between 0.0 - 1.0) and a gesture score is equal to or higher than the specified value, the search is immediately halted and the on_search_complete event is fired (+ the on_complete event of the associated :class:`ProgressTracker` instance). Default is None (disabled). `timeout` Specifies a timeout (in seconds) for when the search is aborted and the results returned. This option applies only when `max_gpf` is not 0. Default value is 0, meaning all gestures in the database will be tested, no matter how long it takes. `max_gpf` Specifies the maximum number of :class:`MultistrokeGesture` objects that can be processed per frame. When exceeded, will cause the search to halt and resume work in the next frame. Setting to 0 will complete the search immediately (and block the UI). .. Warning :: This does not limit the number of :class:`UnistrokeTemplate` objects matched! If a single gesture has a million templates, they will all be processed in a single frame with max_gpf=1! `delay` Sets an optional delay between each run of the recognizer loop. Normally, a run is scheduled for the next frame until the tasklist is exhausted. If you set this, there will be an additional delay between each run (specified in seconds). Default is 0, resume in the next frame. `force_numpoints` forces all templates (and candidate) to be prepared to a certain number of points. This can be useful for example if you are evaluating templates for optimal n (do not use this unless you understand what it does). Zmax_gpfcompleter"csddS)N on_completedispatch)dt)resultrr result_hack(sz)Recognizer.recognize..result_hackc sj}d}|sĈrĈjsĈr*j|krĈ rLtj krLd_d}qĈ}|jf\}}}}|dk r||||}dk r|krd_d}j |7_ jd7_ dq fdd} sd _| Sjrd _| S|r| St dSdS) NFtimeoutT goodscore on_progresscsdddS)Nrr"Frr)rr&rr _dispatchKs  z@Recognizer.recognize.._recognize_tick.._dispatchrstop) _completed _break_flagrget_time _start_timestatuspopleftmatch_candidate _add_result _match_opsr schedule_once) rZstart_gcZstop_nowrDrdresmosscorer ZGPF_recognize_tickcanddelayrr'rr&rBrrr r.sL    z-Recognizer.recognize.._recognize_tickr!r) r7 DEFAULT_GPFrF _candidaterr?rrrr)r&r@rrrr'rrrr recognizes B      0   zRecognizer.recognizecKslt|tr|St|tr.t|r.t|dts6tdt|}|dd}|dkrZd|_n|dkrhd|_|S)Nrz,recognize() needs strokes= list or Candidater.FT)r8rr9r?rr7 skip_boundedskip_invariant)r&r@r'rZo_filterrrr rfs   zRecognizer._candidatecCsdSr1rr&rrrr r!}szRecognizer.on_search_startcCsdSr1rrrrr r"szRecognizer.on_search_complete)N)NN)Nrr)rrr__doc__rr0r$rFrHr[rurzr~rrrr!r" __classcell__rrr(r rs  ' &   rcs`eZdZdZfddZeddZeddZdd Zd d Z d d Z ddZ ddZ Z S)ra Represents an ongoing (or completed) search operation. Instantiated and returned by the :meth:`Recognizer.recognize` method when it is called. The `results` attribute is a dictionary that is updated as the recognition operation progresses. .. Note :: You do not need to instantiate this class. :Arguments: `candidate` :class:`Candidate` object to be evaluated `tasks` Total number of gestures in tasklist (to test against) :Events: `on_progress` Fired for every gesture that is processed `on_result` Fired when a new result is added, and it is the first match for the `name` so far, or a consecutive match with better score. `on_complete` Fired when the search is completed, for whatever reason. (use `ProgressTracker.status` to find out) :Attributes: `results` A dictionary of all results (so far). The key is the name of the gesture (ie :attr:`UnistrokeTemplate.name` usually inherited from :class:`MultistrokeGesture`). Each item in the dictionary is a dict with the following entries: `name` Name of the matched template (redundant) `score` Computed score from 1.0 (perfect match) to 0.0 `dist` Cosine distance from candidate to template (low=closer) `gesture` The :class:`MultistrokeGesture` object that was matched `best_template` Index of the best matching template (in :attr:`MultistrokeGesture.templates`) `template_results` List of distances for all templates. The list index corresponds to a :class:`UnistrokeTemplate` index in gesture.templates. `status` `search` Currently working `stop` Was stopped by the user (:meth:`stop` called) `timeout` A timeout occurred (specified as `timeout=` to recognize()) `goodscore` The search was stopped early because a gesture with a high enough score was found (specified as `goodscore=` to recognize()) `complete` The search is complete (all gestures matching filters were tested) c shd|_||_i|_||_t|_d|_d|_d|_ | d| d| dt t |j f|dS)NsearchrFrr on_result)r candidateresultstasksrrrrrrr%r#rr$)r&rrr'r(rr r$s    zProgressTracker.__init__cCs|js dS|jt|jS)z\Returns the progress as a float, 0 is 0% done, 1 is 100%. This is a Python property.r)rrfloatr&rrr progressszProgressTracker.progresscsN|jsddddStfddd}|d|d|d dS) aReturn the best match found by recognize() so far. It returns a dictionary with three keys, 'name', 'dist' and 'score' representing the template's name, distance (from candidate path) and the computed score value. This is a Python property.Nr)r*distrcs |dS)Nrr)rrrr r3r4z&ProgressTracker.best..r5r*rr)rmax)r&brrr bests    zProgressTracker.bestcCs d|_dS)zRaises a stop flag that is checked by the search process. It will be stopped on the next clock tick (if it is still running).TN)rrrrr rszProgressTracker.stopcCs|t|kr|j|j}ndS||jks:||j|dkr|||||d|j|<|sdd|j|d<nd|t|j|d<|d|j||j|dSdSdS)Nr)r*rrDZ best_templateZtemplate_results?rr)r? templatesr*rr r)r&rDrrrr2rrr rs   zProgressTracker._add_resultcCsdSr1rrrrr rszProgressTracker.on_completecCsdSr1rrrrr rszProgressTracker.on_progresscCsdSr1rrrrr rszProgressTracker.on_result)rrrrr$propertyrrrrrrrrrrr(r rs>   rc@sVeZdZdZdddZddZddd Zdd d Zd d ZddZ ddZ ddZ dS)ra9 :class:`MultistrokeGesture` represents a gesture. It maintains a set of `strokes` and generates unistroke (ie :class:`UnistrokeTemplate`) permutations that are used for evaluating candidates against this gesture later. :Arguments: `name` Identifies the name of the gesture - it is returned to you in the results of a :meth:`Recognizer.recognize` search. You can have any number of MultistrokeGesture objects with the same name; many definitions of one gesture. The same name is given to all the generated unistroke permutations. Required, no default. `strokes` A list of paths that represents the gesture. A path is a list of Vector objects:: gesture = MultistrokeGesture('my_gesture', strokes=[ [Vector(x1, y1), Vector(x2, y2), ...... ], # stroke 1 [Vector(), Vector(), Vector(), Vector() ] # stroke 2 #, [stroke 3], [stroke 4], ... ]) For template matching purposes, all the strokes are combined to a single list (unistroke). You should still specify the strokes individually, and set `stroke_sensitive` True (whenever possible). Once you do this, unistroke permutations are immediately generated and stored in `self.templates` for later, unless you set the `permute` flag to False. `priority` Determines when :func:`Recognizer.recognize` will attempt to match this template, lower priorities are evaluated first (only if a priority `filter` is used). You should use lower priority on gestures that are more likely to match. For example, set user templates at lower number than generic templates. Default is 100. `numpoints` Determines the number of points this gesture should be resampled to (for matching purposes). The default is 16. `stroke_sensitive` Determines if the number of strokes (paths) in this gesture is required to be the same in the candidate (user input) gesture during matching. If this is False, candidates will always be evaluated, disregarding the number of strokes. Default is True. `orientation_sensitive` Determines if this gesture is orientation sensitive. If True, aligns the indicative orientation with the one of eight base orientations that requires least rotation. Default is True. `angle_similarity` This is used by the :func:`Recognizer.recognize` function when a candidate is evaluated against this gesture. If the angles between them are too far off, the template is considered a non-match. Default is 30.0 (degrees) `permute` If False, do not use Heap Permute algorithm to generate different stroke orders when instantiated. If you set this to False, a single UnistrokeTemplate built from `strokes` is used. NcKs||_|dd|_|dd|_|dd|_|dd|_|dd |_g|_|dk r||_|d drv|n"t |d d |D|j|jd g|_ dS)Nr+r]r-r^Zstroke_sensitiveTr.rar_permutecSsg|]}|D]}|q qSrrrIsubirrr rLgsz/MultistrokeGesture.__init__..pointsr-r.) r*r7r+r-r`r>rar@rrrrGrrr r$Xs    zMultistrokeGesture.__init__cCs t|jSr1)r rarrrr angle_similarity_thresholdksz-MultistrokeGesture.angle_similarity_thresholdFcCs|j||r|dS)zAdd a stroke to the self.strokes list. If `permute` is True, the :meth:`permute` method is called to generate new unistroke templatesN)r@r=r)r&strokerrrr add_strokens zMultistrokeGesture.add_strokec Cs|}|dks|dkr|j}||}|||j}d}d}tdt|dD]\} ||| || || d|| d7}||| || d|| d|| 7}qJt||} |t| |t| } | dkrd} n | dkrd} t | S)a!Compute the distance from this Candidate to a UnistrokeTemplate. Returns the Cosine distance between the stroke paths. `numpoints` will prepare both the UnistrokeTemplate and Candidate path to n points (when necessary), you probably don't want to do this. Nrrrr{) r- get_vectorget_protractor_vectorr>xranger?r math_cosmath_sinr ) r&rrr-r2Zv1Zv2arrZanglerrrr get_distanceus" ,. zMultistrokeGesture.get_distancecKstd}d}d}g}|jr:t|jt|jkr:||||fS|j}|j}|j} |} t|j D]r\} } | j rt|rzq^n|rzq^|d7}| d| j } |j | | d}|| krq^| || | d}||||kr^|}| }q^||||fS)aMatch a given candidate against this MultistrokeGesture object. Will test against all templates and report results as a list of four items: `index 0` Best matching template's index (in self.templates) `index 1` Computed distance from the template to the candidate path `index 2` List of distances for all templates. The list index corresponds to a :class:`UnistrokeTemplate` index in self.templates. `index 3` Counter for the number of performed matching operations, ie templates matched against the candidate infinityNrrr)r-)rr`r?r@rrrr enumeraterr>r7r-get_angle_similarityr=)r&rr'Zbest_dZbest_tplrrCrrrZang_sim_thresholdidxrr2Zang_simrrrr rs6  z"MultistrokeGesture.match_candidatecsVddtdtjD_g_tj`fddD_`dS)aGenerate all possible unistroke permutations from self.strokes and save the resulting list of UnistrokeTemplate objects in self.templates. Quote from http://faculty.washington.edu/wobbrock/pubs/gi-10.2.pdf :: We use Heap Permute [16] (p. 179) to generate all stroke orders in a multistroke gesture. Then, to generate stroke directions for each order, we treat each component stroke as a dichotomous [0,1] variable. There are 2^N combinations for N strokes, so we convert the decimal values 0 to 2^N-1, inclusive, to binary representations and regard each bit as indicating forward (0) or reverse (1). This algorithm is often used to generate truth tables in propositional logic. See section 4.1: "$N Algorithm" of the linked paper for details. .. Warning :: Using heap permute for gestures with more than 3 strokes can result in very large number of templates (a 9-stroke gesture = 38 million templates). If you are dealing with these types of gestures, you should manually compose all the desired stroke orders. cSsg|]}|qSrr)rIrrrr rLsz.MultistrokeGesture.permute..rcs"g|]}tj|jjdqS)r)rr*r-r>)rIZ permutationrrr rLsN)rr?r@_order_orders _heap_permute_make_unistrokesrrrrr rs zMultistrokeGesture.permutecCs|j}|dkr$|j|ddnxd}td|D]h}||d|ddkrv|d}||d|d<|||d<q2||}||d||<|||d<q2dS)Nrrr)rrr=rr)r&r2Z self_orderrtmprrr r s z MultistrokeGesture._heap_permutec Csg}|j}|j}|jD]}d}|tdt|krg}|j}tdt|D]D}|||dd} ||?d@dkrx| |d| |dd<qH|||d7}qq|S)Nrrrr{)r=r@rrr?rreverse) r&Z unistrokesZunistrokes_appendZ self_strokesrrZ unistrokeZunistroke_appendrZptsrrr rs"  z#MultistrokeGesture._make_unistrokes)N)F)N) rrrrr$rrrrrrrrrrr rs9   'C*rc@sTeZdZdZdddZddZdddZdd d Zdd d Zdd dZ dddZ dS)raRepresents a (uni)stroke path as a list of Vectors. Normally, this class is instantiated by MultistrokeGesture and not by the programmer directly. However, it is possible to manually compose UnistrokeTemplate objects. :Arguments: `name` Identifies the name of the gesture. This is normally inherited from the parent MultistrokeGesture object when a template is generated. `points` A list of points that represents a unistroke path. This is normally one of the possible stroke order permutations from a MultistrokeGesture. `numpoints` The number of points this template should (ideally) be resampled to before the matching process. The default is 16, but you can use a template-specific settings if that improves results. `orientation_sensitive` Determines if this template is orientation sensitive (True) or fully rotation invariant (False). The default is True. .. Note:: You will get an exception if you set a skip-flag and then attempt to retrieve those vectors. NcKs@||_|dd|_|dd|_i|_g|_|dk r<||_dS)Nr-r^r.T)r*r7r-r>r0r)r&r*rr'rrr r$NszUnistrokeTemplate.__init__cCs|j|i|_dS)z\Add a point to the unistroke/path. This invalidates all previously computed vectors.Nrr=r0)r&rXrrr add_pointYs zUnistrokeTemplate.add_pointcCs0|r|p |j}||jkr"|||j||Sr1r-r0r)r&r6r-r2rrr _get_db_keyas  zUnistrokeTemplate._get_db_keycCs |d|S)N startvectorrr&r-rrr get_start_unit_vectorgsz'UnistrokeTemplate.get_start_unit_vectorcCs |d|S)Nvectorrrrrr rjszUnistrokeTemplate.get_vectorcCs |d|S)Nrrrrrr get_pointsmszUnistrokeTemplate.get_pointscCs|jstd|p|j}|r$|dkr,tdt|j|}t|}t|| }t|tt}|j rjt|| }t |t }t ||dt ||j d|j|<dS)zThis function prepares the UnistrokeTemplate for matching given a target number of points (for resample). 16 is optimal.z$prepare() called without self.pointsrz'prepare() called with invalid numpoints)rrN)rrr-resampleindicative_angle rotate_by scale_dim SQUARESIZE ONEDTHRESHOLDr> translate_toORIGINstart_unit_vector vectorizer0)r&r-r2rXr rrr rps         zUnistrokeTemplate.prepare)N)N)N)N)N)N) rrrrr$rrrrrrrrrr r5s     rc@sLeZdZdZdddZddZdd Zd d Zd d ZddZ dddZ dS)raDRepresents a set of unistroke paths of user input, ie data to be matched against a :class:`UnistrokeTemplate` object using the Protractor algorithm. By default, data is precomputed to match both rotation bounded and fully invariant :class:`UnistrokeTemplate` objects. :Arguments: `strokes` See :data:`MultistrokeGesture.strokes` for format example. The Candidate strokes are simply combined to a unistroke in the order given. The idea is that this will match one of the unistroke permutations in `MultistrokeGesture.templates`. `numpoints` The Candidate's default N; this is only for a fallback, it is not normally used since n is driven by the UnistrokeTemplate we are being compared to. `skip_bounded` If True, do not generate/store rotation bounded vectors `skip_invariant` If True, do not generate/store rotation invariant vectors Note that you WILL get errors if you set a skip-flag and then attempt to retrieve the data.Nr^cKs@|dd|_|dd|_||_i|_g|_|dk r<||_dS)NrFr)r7rrr-r0r@)r&r@r-r'rrr r$szCandidate.__init__cCs|j|i|_dS)z[Add a stroke to the candidate; this will invalidate all previously computed vectorsNr)r&rrrr rs zCandidate.add_strokecCs@|r|p |j}||jkr"|||r*dp,d}|j|||S)NZbound_Zinv_r)r&r6r-r>r2prefixrrr rs    zCandidate._get_db_keycCs|d||S)a(Internal use only) Get the start vector for this Candidate, with the path resampled to `numpoints` points. This is the first step in the matching process. It is compared to a UnistrokeTemplate object's start vector to determine angle similarity.rrr&r-r>rrr rszCandidate.get_start_unit_vectorcCs|d||S)z^(Internal use only) Return vector for comparing to a UnistrokeTemplate with Protractorrrrrrr rszCandidate.get_protractor_vectorcKs^|d|j}|||j\}}||\}}||||}|dkrJdS|dkrVtSt|S)z(Internal use only) Compute the angle similarity between this Candidate and a UnistrokeTemplate object. Returns a number that represents the angle similarity (lower is more similar).r-rrr{)r7r-rr>r r )r&rr'r2Zv1xZv1yZv2xZv2yrrr rszCandidate.get_angle_similarityc Cs|r|p |j}dd|jD}t||}t|}t|| }t|tt}|d}i}|jst |t }t |||d<t |d|d<|j st|| }t |t }t |||d<t |d|d <||j|<d S) aPrepare the Candidate vectors. self.strokes is combined to a single unistroke (connected end-to-end), resampled to :attr:`numpoints` points, and then the vectors are calculated and stored in self.db (for use by `get_distance` and `get_angle_similarity`)cSsg|]}|D]}|q qSrrrrrr rLsz%Candidate.prepare..rZinv_startvectorFZ inv_vectorZbound_startvectorTZ bound_vectorN)r-r@rrrrrrrrrrrrr0) r&r-r2rr ZangidxrZ inv_pointsZ bound_pointsrrr rs$      zCandidate.prepare)Nr^)N) rrrrr$rrrrrrrrrr rs rcCsBt|r|r|dkrtdt||d}d}d}|dg}|dd}d}t|}|j} |j} |t|kr(||d} ||} t| | } || |kr| d||| | d| d}| d||| | d| d}t||}| || |||d7}|d7}d}n|| 7}|d7}qb||kr>| |d|S)Nrz(resample() called with invalid argumentsrrrr{)r?r path_lengthr=insertdistancer)rr2intervalDr newpointsZ workpointsZ newpoints_lenZworkpoints_lenZ new_appendZ work_insertp1p2rqxqyqrrr r s:    $$     rcCs.t|\}}t||dd||ddSNrr)centroidr)rcxcyrrr r5s rc Cst|\}}t|}t|}g}|j}tdt|D]j}||d||||d|||} ||d||||d|||} |t| | q4|Sr)rrrr=rr?r) rr rrrrrnewpoints_appendrrrrrr r:s ,,rcCst|\}}}}|dks |dkr0td||t|||||k}|rh|t||}|t||} n||}||} g} | j} |D]*} | d|} | d| }| t| |q| S)Nrz2scale_dim() called with invalid points: h:{}, w:{}r) bounding_boxrformatminrr=r)rsizeZ oneDratioZbbox_xZbbox_yZbbox_wZbbox_hZ uniformlyZqx_sizeZqy_sizerrrXrrrrr rJs*  rc CsVt|\}}|\}}g}|D]4}|d||}|d||} |t|| q|Sr)rr=r) rptrrZptxZptyrrXrrrrr rgs rcCsd}d}|r^t|dd|dd}tdt|tdtd}t||}t||}d}g}d}|j} |D]T\} } | || |} | || |} | | | | |d7}|| d| d7}qtt|}td|D]}|||<q|S)Nrrrrg@g @r)rr rrrr=r r)rZuse_bounded_rotation_invariancerrangZbosumrZ vector_lenZ vector_appendpxpyZnewxZnewyZ magnituderrrr rss,    rcCsZd}d}t|}td|D]$}|||d7}|||d7}q||}||}t||S)Nrrr)r?rr)rrJrKZ points_lenrrrr rsrcCsztd}td}td}td}|D]8\}}||kr8|}||krD|}||krP|}||kr$|}q$||||d||dfS)Nrz -infinityr)r)rZminxZminyZmaxxZmaxyrrrrr rs rcCs6d}tdt|D]}|t||d||7}q|S)Nrr)rr?r)rrrrrr rsrcCs4|d|d}|d|d}t|d|dSNrrr)r )rrZdxZdyrrr rsrcCs`t|}||d|dd||d|dd}}t|d|d}t||||Sr)r:r r)rindexrZvxZvylengthrrr rs2r)sVv  (       n`w)