I wrapped their latest recognizer the $P Point-Cloud Recognizer, as a node.js module here: 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

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.

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

I really love the feedback in the demo as to what the recognizer is guessing. If my Palm had that I believe I might have been even faster at writing graffiti. It allows you to quickly correct a "letterform" to get the desired glyph.

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

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

"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...."

Also, the following $N multistroke recognizer: https://depts.washington.edu/aimgroup/proj/dollar/ndollar.ht...

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

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.

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.

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

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

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

graffiti was excellent, we should look into reintroducing it for VR applications. you add touchpads to VR wands and you could have decent enough wpm.

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.

I'm confused by the name too. It seemed abundantly clear that they were hoping to collect a micropayment from people who used the software, until I read more and it turned out to just be the name of the software.

> 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

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

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.

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?

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.

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

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)

I built a game around this recognizer ("Magic Touch": 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!

Drawing anything with a clockwise motion I got a caret.

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.

Sam here. The direction/ordering of the stroke seems important, I wonder why?

They could 'fix' this by adding reverse forms of each of the strokes. I wonder why they haven't? Does doing so drastically reduce the detection accuracy?

I've downloaded the PDF for the paper linked on the page (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?

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.

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.

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.

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

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

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.

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.

I had trouble getting it to recognize my "arrow"

The arrow has to be made by starting the head on the left side, drawing back to the center, and ending on the right

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

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

Once you get that, it's fairly accurate.

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

backward C gives me a caret

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.

"Check" is detected as "left square bracket" if the end of the stroke curves up slightly.