It’s still early in development (read: it often crashes), but The Bean Machine applies nodal, patch-based development to Java. The interface is mysteriously close to Quartz Composer, down to capabilities, UI, and even the 3D cube tutorial. Personally, I use Java because it can do things Quartz Composer can’t, but it’s interesting nonetheless — and raises, again, the question of why we don’t see more tools that try to meld the capabilities of code and patches.

The cool bit: nodes are Java Beans, so you really could use this to combine the best of both worlds if it matures. No download yet, but we’ll be watching … perhaps it will inspire other developers, as well.

The project is labeled “experimental”, but could be worth a look. Developer Jerry Huxtable has lots of other goodies for Java-heads on his page, including lots of 2D image processing stuff and a map editor — Processing lovers, might want to pop this into your del.icio.us.

Bean Machine @ JH Labs

JH Labs main page with lots o’ projects

It’s a beach.

“Content-aware” image resizing — the ability to stretch images without distortion — is all the rage. vade covered the technology at last summer’s SIGGRAPH, and we’ve since seen publicly-available tools. But the New York Times musters an entire feature story on the topic (now it’s definitely mainstream), complete with a monster round-up of tools.

Thanks to Emmet for the tip!

Learning Processing

“Is there a good, basic tutorial for Processing?”

This question gets asked all the time. Processing is a powerful, open source, cross-platform (Mac, Windows, Linux) tool capable of all kinds of multimedia magic from video processing to generative 2D and 3D art and animation. There’s no graphical UI, just simplified Java code, but it really is simple enough to be used by non-programmers — frankly, I find it much easier than ActionScript (Flash) or Lingo (Director). But download it, and it’ll be extremely unclear where to begin. There’s no step-by-step tutorial, just a reference to commands and some sample code.

Fortunately, Josh Nimoy — the NYU whiz who created the excellent JMyron computer vision library — has written just the kind of “Processing quick start” you need:

Processing Tutorial for Macromedia Minds

It’ll be particularly friendly if you come from Director or even Flash. There are also a couple of reference books due, one from Processing’s original creators and another, more practical reference, in the works for next year by NYU faculty Daniel Shiffman. Even after those books have come out, though, I expect people will still find a quick start useful. If you’re trying to learn Processing or even just want to see an overview of what it is and how it works, this is for you.

Incidentally, ignore the references to Proce55ing and P5; when Processing had zero Google rank for confusion with other forms of (lower-case) processing, this odd spelling was needed. Now, virtually no one uses these names.

Teaching Computers to See

Processing happens to be a great environment for working with computer vision applications, but that brings us to the next question: what’s computer vision, and how do you learn about that? Computer vision is a broad term applied to various techniques for teaching computers to “see” the way we do. This can be very simple, like basic motion detection and using frame differencing to display parts of an image that change from frame to frame. It can also be more sophisticated and interactive, from basic collision-detection with individual pixels to tracking discrete objects as they move around the screen.

Working with computer vision is a little like working with video in general: some of the basic techniques are simple and commonly-understood, but turning them into something artistic is easily a lifetime endeavor. That said, here’s one of the best places to start I’ve seen yet:

eating video: Workshop by Zachary Lieberman

Zach Lieberman is best known for his work on Messa di Voce, a beautiful interactive music piece with simple but elegant animations of circles and other shapes floating around performers and appearing to stream out of their mouths. For this workshop in Barcelona, he provides some terrific background reading (including the tutorial above), plus various code examples in Processing.

This is extremely basic stuff in the workshop examples, but it’s a good place to start. (Windows users will need WinVDIG as this uses the built-in Processing capture library and QuickTime for Java.) Next, I’d suggest turning to JMyron (which also saves Windows users the trouble of using WinVDIG); check out the examples included with that download:

Myron aka webcamxtra aka JMyron from Josh Nimoy

Read through these materials, work through Josh’s tutorial, and work through the examples in JMyron, and you’ll be well on your way to creating some basic interactive motion pieces in Processing. I’ve been developing some of my own, so since that last step isn’t terribly well-documented, stay glued to Create Digital Motion and I’ll try to write something up in the next couple of weeks.

As someone relatively new to Processing, I’ve experienced equal parts excitement and frustration. 0115 is a reasonably mature build, and I’m glad I didn’t try this earlier, but more advanced work is likely to get easier as the software develops, improves, and squashes bugs.

Before I dive into the full, technical explanation for those of you using Processing, here’s the Cliff Notes version:

1. Processing is great, but think of it as a sketchpad — and “beta” is accurate; prepare to hit up against some limitations that could become a time suck if your project is dependent on them.
2. OpenGL rendering works, but has major limitations when mixing pixel processing. Then again, you’ll want to use Processing’s other built-in rendering engines so you can share your work on the Web, so try those, and consider waiting on your OpenGL sketches until the bugs are fixed.
3. Video capture on Windows (and Mac, to a lesser extent) can be a pain because of QuickTime for Java. JMyron works around this on Windows with DirectX, but there is an important caveat; again, you may find things feel like a work in progress.
4. JMyron is fantastic for doing simple motion tracking without a lot of coding. (Here’s where Processing wins; Jitter and cv.jit, for instance, are much harder to use in this area.) Example image below from JMyron’s site.

Interesting example of using JMyron/Processing: Shadow Monsters [Pixelsumo entry]

Apologies to anyone who’s on Processing overload, but we keep finding fantastic work. Quasimondo’s Rubber Screen maps an image to a 3d mesh and then lets it jiggle like hyperactive Jell-o. The still image doesn’t do it justice; you have to try it out. Like the 90s app Goo, you can warp images in comical ways. Unlike Goo, though, everything happens in real-time, with physically-realistic animations and various cool tools. This also gives me hope for the possibilities of coding physical dynamics and fluid models in Processing and Java. (Sadly, no source code, but just playing around with it should spark some ideas.)

I know there are other projects similar to this. Got a favorite? Let us know.