
$1 Unistroke Recognizer - tambourine_man
https://depts.washington.edu/aimgroup/proj/dollar/?hn
======
endergen
I wrapped their latest recognizer the $P Point-Cloud Recognizer, as a node.js
module here:
[https://github.com/francoislaberge/outlines](https://github.com/francoislaberge/outlines)

Their implementation is quite clean, it really is a nice clean algorithm. It
takes reading it to understand the type of shapes (templates) that work best
and also as a user how best to draw them. I added a demo that shows you as you
draw what it's internal state is and best guess so far:
[http://francoislaberge.com/outlines/demo/index.html](http://francoislaberge.com/outlines/demo/index.html)

~~~
sgentle
Very cool. It's interesting that, depending on how I draw it, I get a much
higher match for "D" when I draw a box than when I draw a D.

It seems like it might be tricky to train it on what not to recognise. Or
maybe you just need a lot of template gestures.

~~~
endergen
Yeah, I think you really have to design your set of recognized gestures to
make them have a low chance of ambiguity.

Hmmm, and yeah you could add templates that are variants of an intended
output. To improve the chance of matching important gestures

------
wodenokoto
There's also a 1¢ recognizer, which supposedly improves this one in every way,
yet has gone about fairly unnoticed, comparatively.

[http://dl.acm.org/citation.cfm?id=2331074](http://dl.acm.org/citation.cfm?id=2331074)

~~~
logicallee
[https://en.wikipedia.org/wiki/Nominative_determinism](https://en.wikipedia.org/wiki/Nominative_determinism)

~~~
wodenokoto
you need to expand on your point, because I don't get at all.

~~~
logicallee
"There's also a 1¢ recognizer, which supposedly improves on the $1 recognizer
in every way, yet for some reason isn't valued as highly...."

------
conradev
Also, the following $N multistroke recognizer:
[https://depts.washington.edu/aimgroup/proj/dollar/ndollar.ht...](https://depts.washington.edu/aimgroup/proj/dollar/ndollar.html)

I built a pretty cool tweak for iOS 5 that integrated it into the operating
system:

[https://www.youtube.com/watch?v=35SX6A9fE0g](https://www.youtube.com/watch?v=35SX6A9fE0g)

I haven't thought about it in a long time, but I still think that these
gestures could be a great shortcut interface for a multi-touch OS, especially
with pressure sensitivity. A deep press could activate the gesture recognizer.

~~~
Sanddancer
My brain can't help but think that we've kinda gone full circle here when
simple-stroke gesture recognition is thought of as an interesting new
interface idea. I mean, it's been about twenty years since a little app called
Graffiti from a little company called Palm gave a brand new way of interfacing
with an Apple handheld. Not knocking you at all, because it's a pretty cool
app, just commentary on how history repeats itself.

------
userbinator
I wonder how the CPU and RAM requirements compare to this:

[https://en.wikipedia.org/wiki/Graffiti_(Palm_OS)](https://en.wikipedia.org/wiki/Graffiti_\(Palm_OS\))

~~~
mentat
Back in the day I got quite decent at using that to take notes in class. Was
an interesting tool.

------
PhasmaFelis
Article did not answer my first question, which is why this thing is called
"$1". I clicked expecting to discover some sort of cheap hardware device.

~~~
pkamb
> 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

~~~
PhasmaFelis
That's a little clearer, but it's also not in the linked article.

------
murbard2
Note, this is released freely under the new BSD license; it is not being sold
for the one U.S. dollar; it's just name.

------
asgard1024
It seems (from my experiments) that recognition treats all rotations of
objects equally. So for instance it recognizes right bracket as left if drawn
backwards. I think there should be a caveat warning there.

I think it's a neat toy, but frankly I don't understand what attracts GUI
designers to gestures. They seem lot more complicated than just buttons (even
if you would have to push an extra button to get the menu), they are not
obvious and you have to learn them to do correctly. Am I missing something?

~~~
walrus
I like gestures for the same reason I like keyboard shortcuts: you don't have
to aim. There's a tradeoff in UIs: large number of targets with few actions,
or large number of actions with few targets. An example of the former is a
typical web page, where every link is a target and the only actions are open
and open-in-tab. An example of the latter is vim, where there are only a
couple targets (buffer and command bar) and every key is an action.

------
imauld
Am I supposed to not be able to see what I'm drawing?

------
drcode
It would be awesome if someone used this to create a note-taking tool for
apple/android smart watches that used the graffiti alphabet:
[https://en.wikipedia.org/wiki/Graffiti_(Palm_OS)](https://en.wikipedia.org/wiki/Graffiti_\(Palm_OS\))

------
birslip
I built a game around this recognizer ("Magic Touch":
[https://www.youtube.com/watch?v=Ze9k0lseb-8](https://www.youtube.com/watch?v=Ze9k0lseb-8)
). It's a very neat way to do shape recognition in real time. It's very well
suited for mobile devices although it's far from being perfect. The
interesting bit was to make the recognition lenient enough but still good
enough to recognize the shapes accurately. Think about the difference between
a 'V' and a 'U'. Anyway I would love to see more real world uses of this
clever recognizer!

------
daurnimator
Drawing anything with a clockwise motion I got a caret.

~~~
akovaski
I think this just recognizes your gestures (i.e. it does not recognize shapes
you draw). I added an example of a clockwise triangle (using the site's "Add
as example of existing type") and it was then able to recognize clockwise
triangles.

------
lindig
I've downloaded the PDF for the paper linked on the page
([http://faculty.washington.edu/wobbrock/pubs/uist-07.01.pdf](http://faculty.washington.edu/wobbrock/pubs/uist-07.01.pdf))
and some of the images are not showing. Is this a problem with OS X
Preview.app or a general problem?

------
hollerith
The software assigns _any_ sufficiently long user input to one of the 16
gestures.

In contrast, human-to-human communication consider much (most?) of the space
of possible speech acts to be gibberish.

In other words, the software never gives up on trying to classify a user-input
sequence no matter how wacky it is.

~~~
yertle_vert
Yes, but it does returns a match certainty value (0-1). If you used this
library you could just assume gibberish if below 0.8 for example.

------
dthal
I've played around with this some, and the recognition isn't perfect, but I'm
very impressed with how well it can pick up a new pattern from even just one
example.

------
dragontamer
If you draw brackets from bottom up they are recorded inverted.

For example, } drawn from bottom up is "recognized" as {.

~~~
regularfry
That's because it's rotationally insensitive, which is a rather interesting
property. I'm not sure how useful it is, but it certainly surprised me.

~~~
mmusson
When I used this code for a simple application, I made a small change to the
recognized to limit the rotational invariance so that a gesture that was
rotated more than a certain angle threshold would not match.

------
dleibovic
I had trouble getting it to recognize my "arrow"

~~~
QuercusMax
Same here. It seems like it's very picky.

~~~
intruder
Stroke order matters. As does amount of strokes per gesture.

Once you get that, it's fairly accurate.

------
airza
is there a browser that still supports these gestures? Firefox did 10 years
ago with an addon...

------
aqwwe
backward C gives me a caret

~~~
bazzargh
Add your drawing as a template, and try again. The point of the $1-family of
recognizers is not what they recognize 'out of the box' but that they're very
simple to code, and it's easy to extend them by adding example gestures.

