手势识别，$1手势识别资源-CSDN文库

共13个文件

cpp：3个

txt：2个

opt：1个

手势识别

源码

$1手势识别

论文

1星需积分: 34 16 浏览量 2012-06-14 15:21:22 上传评论 1 收藏 776KB RAR 举报

资源推荐

资源详情

资源评论

收起资源包目录

手势识别.rar （13个子文件）

手势识别

使用说明.txt 265B

other.cpp 2KB

demo.dsw 533B

demo.plg 1KB

main.cpp 6KB

demo.opt 49KB

gesture.cpp 7KB

demo.dsp 4KB

演示程序.exe 620KB

手势识别论文.pdf 702KB

demo.ncb 81KB

define.h 2KB

Resource.txt 18KB

Gestures without Libraries, Toolkits or Training:

A $1 Recognizer for User Interface Prototypes

Jacob O. Wobbrock

The Information School

University of Washington

Mary Gates Hall, Box 352840

Seattle, WA 98195-2840

wobbrock@u.washington.edu

Andrew D. Wilson

Microsoft Research

One Microsoft Way

Redmond, WA 98052

awilson@microsoft.com

Yang Li

Computer Science & Engineering

University of Washington

The Allen Center, Box 352350

Seattle, WA 98195-2350

yangli@cs.washington.edu

ABSTRACT

Although mobile, tablet, large display, and tabletop

computers increasingly present opportunities for using pen,

finger, and wand gestures in user interfaces, implementing

gesture recognition largely has been the privilege of pattern

matching experts, not user interface prototypers. Although

some user interface libraries and toolkits offer gesture

recognizers, such infrastructure is often unavailable in

design-oriented environments like Flash, scripting

environments like JavaScript, or brand new off-desktop

prototyping environments. To enable novice programmers

to incorporate gestures into their UI prototypes, we present

a “$1 recognizer” that is easy, cheap, and usable almost

anywhere in about 100 lines of code. In a study comparing

our $1 recognizer, Dynamic Time Warping, and the Rubine

classifier on user-supplied gestures, we found that $1

obtains over 97% accuracy with only 1 loaded template and

99% accuracy with 3+ loaded templates. These results were

nearly identical to DTW and superior to Rubine. In

addition, we found that medium-speed gestures, in which

users balanced speed and accuracy, were recognized better

than slow or fast gestures for all three recognizers. We also

discuss the effect that the number of templates or training

examples has on recognition, the score falloff along

recognizers’ N-best lists, and results for individual gestures.

We include detailed pseudocode of the $1 recognizer to aid

development, inspection, extension, and testing.

ACM Categories & Subject Descriptors: H5.2.

[Information interfaces and presentation]: User interfaces –

Input devices and strategies. I5.2. [Pattern recognition]:

Design methodology – Classifier design and evaluation. I5.5.

[Pattern recognition]: Implementation – Interactive systems.

General Terms: Algorithms, Design, Experimentation,

Human Factors.

Keywords: Gesture recognition, unistrokes, strokes, marks,

symbols, recognition rates, statistical classifiers, Rubine,

Dynamic Time Warping, user interfaces, rapid prototyping.

Figure 1. Unistroke gestures useful for making selections,

executing commands, or entering symbols. This set of 16 was used

in our study of $1, DTW [18,28], and Rubine [23].

INTRODUCTION

Pen, finger, and wand gestures are increasingly relevant to

many new user interfaces for mobile, tablet, large display,

and tabletop computers [2,5,7,10,16,31]. Even some

desktop applications support mouse gestures. The Opera

Web Browser, for example, uses mouse gestures to navigate

and manage windows.

As new computing platforms and

new user interface concepts are explored, the opportunity

for using gestures made by pens, fingers, wands, or other

path-making instruments is likely to grow, and with it,

interest from user interface designers and rapid prototypers

in using gestures in their projects.

However, along with the naturalness of gestures comes

inherent ambiguity, making gesture recognition a topic of

interest to experts in artificial intelligence (AI) and pattern

matching. To date, designing and implementing gesture

recognition largely has been the privilege of experts in

these fields, not experts in human-computer interaction

http://www.opera.com/products/desktop/mouse/

Permission to make digital or hard copies of all or part of this work fo

ersonal or classroom use is granted without fee provided that copies are

not made or distributed for profit or commercial advantage and that copies

ear this notice and the full citation on the first page. To copy otherwise,

or republish, to post on servers or to redistribute to lists, requires prio

specific permission and/or a fee.

UIST’07, October 7-10, 2007, Newport, Rhode Island, USA.

(HCI), whose primary concerns are usually not algorithmic,

but interactive. This has perhaps limited the extent to which

novice programmers, human factors specialists, and user

interface prototypers have considered gesture recognition a

viable addition to their projects, especially if they are doing

the algorithmic work themselves.

As an example, consider a sophomore computer science

major with an interest in user interfaces. Although this

student may be a capable programmer, it is unlikely that he

has been immersed in Hidden Markov Models [1,3,25],

neural networks [20], feature-based statistical classifiers

[4,23], or dynamic programming [18,28] at this point in his

career. In developing a user interface prototype, this student

may wish to use Director, Flash, Visual Basic, JavaScript or

a brand new tool rather than an industrial-strength

environment suitable to production-level code. Without a

gesture recognition library for these tools, the student’s

options for adding gestures are rather limited. He can dig

into pattern matching journals, try to devise an ad-hoc

algorithm of his own [4,19,31], ask for considerable help,

or simply choose not to have gestures.

We are certainly not the first to note this issue in HCI. Prior

work has attempted to provide gesture recognition for user

interfaces through the use of libraries and toolkits [6,8,12,

17]. However, libraries and toolkits cannot help where they

do not exist, and many of today’s rapid prototyping tools

may not have such resources available.

On the flip side, ad-hoc recognizers also have their

drawbacks. By “ad-hoc” we mean recognizers that use

heuristics specifically tuned to a predefined set of gestures

[4,19,31]. Implementing ad-hoc recognizers can be

challenging if the number of gestures is very large, since

gestures tend to “collide” in feature-space [14]. Ad-hoc

recognition also prevents application end-users from

defining their own gestures at runtime, since new heuristics

would need to be added.

To facilitate the incorporation of gestures into user interface

prototypes, we present a $1 recognizer that is easy, cheap,

and usable almost anywhere. The recognizer is very simple,

involving only basic geometry and trigonometry. It requires

about 100 lines of code for both gesture definition and

recognition. It supports configurable rotation, scale, and

position invariance, does not require feature selection or

training examples, is resilient to variations in input

sampling, and supports high recognition rates, even after

only one representative example. Although $1 has

limitations as a result of its simplicity, it offers excellent

recognition rates for the types of symbols and strokes that

can be useful in user interfaces.

In order to evaluate $1, we conducted a controlled study of

it and two other recognizers on the 16 gesture types shown

in Figure 1. Our study used 4800 pen gestures supplied by

10 subjects on a Pocket PC. Some of the questions we

address in this paper are: How well does $1 perform on user

interface gestures compared to two more complex

algorithms used in HCI? How does recognition improve as

the number of templates or training examples increases?

How do gesture articulation speeds affect recognition? How

do recognizers’ scores degrade as we move down their N-

best lists? Which gestures do users prefer? Along with

answering these questions, the contributions of this paper

are:

1. To present an easy-to-implement gesture recognition

algorithm for use by UI prototypers who may have

little or no knowledge of pattern recognition. This

includes an efficient scheme for rotation invariance;

2. To empirically compare $1 to more advanced,

theoretically sophisticated algorithms, and to show

that $1 is successful in recognizing certain types of

user interface gestures, like those shown in Figure 1;

3. To give insight into which user interface gestures are

“best” in terms of human and recognizer

performance, and human subjective preference.

We are interested in recognizing paths delineated by users

interactively, so we restrict our focus to unistroke gestures

that unfold over time. The gestures we used for testing

(Figure 1) are based on those found in other interactive

systems [8,12,13,27]. It is our hope that user interface

designers and prototypers wanting to add gestures to their

projects will find the $1 recognizer easy to understand,

build, inspect, debug, and extend, especially in design-

oriented environments where gestures are typically scarce.

RELATED WORK

Various approaches to gesture recognition were mentioned

in the introduction, including Hidden Markov Models

(HMMs) [1,3,25], neural networks [20], feature-based

statistical classifiers [4,23], dynamic programming [18,28],

and ad-hoc heuristic recognizers [4,19,31]. All have been

used extensively in domains ranging from on-line

handwriting recognition to off-line diagram recognition.

Space precludes a full treatment. For in-depth reviews,

readers are directed to prior surveys [21,29].

For recognizing simple user interface strokes like those

shown in Figure 1, many of these sophisticated methods are

left wanting. Some must be trained with numerous

examples, like HMMs, neural networks, and statistical

classifiers, making them less practical for UI prototypes in

which application end-users define their own strokes. These

algorithms are also difficult to program and debug. Even

Rubine’s popular classifier [23] requires programmers to

compute matrix inversions, discriminant values, and

Mahalanobis distances, which can be obstacles. Dynamic

programming methods are computationally expensive and

sometimes too flexible in matching [32], and although

improvements in speed are possible [24], these

improvements put the algorithms well beyond the reach of

most UI designers and prototypers. Finally, ad-hoc methods

scale poorly and usually do not permit adaptation or

definition of new gestures by application end-users.

Previous efforts at making gesture recognition more

accessible have been through the inclusion of gesture

recognizers in user interface toolkits. Artkit [6] and Amulet

[17] support the incorporation of gesture recognizers in user

interfaces. Amulet’s predecessor, Garnet, was extended

with Agate [12], which used the Rubine classifier [23].

More recently, SATIN [8] combined gesture recognition

with other ink-handling support for developing informal

pen-based UIs. Although these toolkits are powerful, they

cannot help in most new prototyping environments because

they are not available.

Besides research toolkits, some programming libraries offer

APIs for supporting gesture recognition on specific

platforms. An example is the Siger library for Microsoft’s

Tablet PC [27], which allows developers to define gestures

for their applications. The Siger recognizer works by

turning strokes into directional tokens and matching these

tokens using regular expressions and heuristics. As with

toolkits, libraries like Siger are powerful; but they are not

useful where they do not exist. The $1 recognizer, by

contrast, is simple enough to be implemented wherever

necessary, even in many rapid prototyping environments.

THE $1 GESTURE RECOGNIZER

In this section, we describe the $1 gesture recognizer. A

pseudocode listing of the algorithm is given in Appendix A.

Characterizing the Challenge

A user’s gesture results in a set of candidate points C, and

we must determine which set of previously recorded

template points T

it most closely matches. Candidate and

template points are usually obtained through interactive

means by some path-making instrument moving through a

position-sensing region. Thus, candidate points are sampled

at a rate determined by the sensing hardware and software.

This fact and human variability mean that points in similar

C and T

will rarely “line up” so as to be easily comparable.

Consider the two pairs of gestures made by the same

subject in Figure 2.

Figure 2. Two pairs of fast (~600 ms) gestures made by a subject

with a stylus. The number of points in corresponding sections are

labeled. Clearly, a 1:1 comparison of points is insufficient.

In examining these pairs of “pigtail” and “x”, we see that

they are different sizes and contain different numbers of

points. This distinction presents a challenge to recognizers.

Also, the pigtails can be made similar to the “x” gestures

using a 90° clockwise turn. Reflecting on these issues and

on our desire for simplicity, we formulated the following

criteria for our $1 recognizer. The $1 recognizer must:

1. be resilient to variations in sampling due to

movement speed or sensing;

2. support optional and configurable rotation, scale, and

position invariance;

3. require no advanced mathematical techniques (e.g.,

matrix inversions, derivatives, integrals);

4. be easily written in few lines of code;

5. be fast enough for interactive purposes (no lag);

6. allow developers and application end-users to

“teach” it new gestures with only one example;

7. return an N-best list with sensible [0..1] scores that

are independent of the number of input points;

8. provide recognition rates that are competitive with

more complex algorithms previously used in HCI to

recognize the types of gestures shown in Figure 1.

With these goals in mind, we describe the $1 recognizer in

the next section. The recognizer uses four steps, which

correspond to those offered as pseudocode in Appendix A.

A Simple Four-Step Algorithm

Raw input points, whether those of gestures meant to serve

as templates, or those of candidate gestures attempting to be

recognized, are initially treated the same: they are

resampled, rotated once, scaled, and translated. Candidate

points C are then scored against each set of template points

over a series of angular adjustments to C that finds its

optimal angular alignment to T

. Each of these steps is

explained in more detail below.

Step 1: Resample the Point Path

As noted in the previous section, gestures in user interfaces

are sampled at a rate determined by the sensing hardware

and input software. Thus, movement speed will have a clear

effect on the number of input points in a gesture (Figure 3).

Figure 3. A slow and fast question mark and triangle made by

subjects using a stylus on a Pocket PC. Note the considerable time

differences and resulting numbers of points.

To make gesture paths directly comparable even at different

movement speeds, we first resample gestures such that the

path defined by their original M points is defined by N

equidistantly spaced points (Figure 4). Using an N that is

too low results in a loss of precision, while using an N that

is too high adds time to path comparisons. In practice, we

found N=64 to be adequate, as was any 32 ≤ N ≤ 256.

Although resampling is not particularly common compared

to other techniques (e.g., filtering), we are not the first to

评论收藏

内容反馈

qwe1518636991

2013-05-18

还以为可以通过摄像头进行手势识别没想到只是鼠标

「已注销」

粉丝: 3
资源: 24

手势识别，$1手势识别

$1单笔画手势识别算法实现

手势检测与识别

指手势识别

简单手势识别

触摸手势识别

手势识别 C++

C++ 手势识别 C ++和OpenCV手掌检测和手指计数 使用C++ opevCV 手势识别

c#实现百度手势识别

FDC2214手势识别

2018电子竞赛手势识别FDC2214

手势的识别

手势识别

手势识别 实现对手势的识别

基于matlab的手势识别.rar_matlab 手势_手势识别MATLAB_手势识别器_石头剪刀布_简单手势识别

matlab手势识别,matlab手势识别代码,matlab

matlab手势识别_MATLAB手势识别_matlab手势识别_tightk1r_识别手势_手势识别MATLAB

array3.zip_MATLAB手势识别_手势_手势算法_手势识别_手势识别算法

基于YOLOv5的手势识别系统(含手势识别数据集 训练代码).txt

opencv 手势识别

手势识别与检测（opencv）

手势识别 C++实现

手势识别_stm32f1_fdc2214

FDC2214手势识别原理图+PCB+中文手册

FDC2214原理图及PCB

opencv手势识别与匹配

opencv实现两种手势识别

基于Opencv的手势识别

手势识别实现

最新资源

C++ 手势识别 C ++和OpenCV手掌检测和手指计数使用C++ opevCV 手势识别

手势识别实现对手势的识别

基于YOLOv5的手势识别系统(含手势识别数据集训练代码).txt