This was done by setting the Tone frequency expressions to reconstruct the appropriate musical pitch:

on = effect("ch_1_vel")("Slider").value ? 1 : 0;
note = effect("ch_1_pitch")("Slider");
on * 440 * Math.pow(2, (note-57)/12)

You could change 12 to something else, to hear it performed in some alternate equal-tempered scale. 8 and 17 sound kind-of interesting…

And here’s the self-contained CS5 project to download.

It was written late one night for a specific purpose. I was doing some promotional animations for my friends’ Science Tarot deck, and got to “High Priestess, Benzene Dream” in which Friedrich August Kekule von Stradonitz dreams of a snake eating its tail. And this was the mystery of the benzene ring-shaped molecule.

I wanted the snake to follow along a path. So, Omino Snake wraps any layer along a mask path, like so:

The results can be a little bit “chunky”; Omino Snake just dices the source image into thin triangles and spreads them out. You can adjust the “draw step” parameter to step in smaller amounts to help smooth it.

You could do the same thing, more or less, by animating with the Puppet tool, but it would be a bit tedious.

And here’s a little demo of it in action.

For anyone just tuning in, Omino Python is an After Effects plug-in that lets you write scripts to draw into a layer of an After Effects composition. It’s a lot like writing BASIC on your old Apple ][.

Changes to the plug-in are primarily:

• Fixed a sporadic crash that could happen during text rendering.
• No longer install any files in /opt/local or /usr/local. All gone.
• Completely unlocked (no license needed for full use). Enjoy!

Here’s a frame from one of the example animations. This is a couple of for-loops in action.

And here’s the animation it came from.

And here’s the python source code.

Hello, pixel pushers and vert herders! Ah, it’s great to be back in After Effects land. Alas in this last year, the day job (got hired by Skype, acquired by Microsoft) and life in general (after throwing elaborate theme-parties for decades, planning a wedding wasn’t actually that hard, but still) got a little busy, but thankfully again have a little bit of time for my favorite things. That is, pixels.

Omino Python Since I released it this year, it’s been downloaded several thousand times, and about a dozen enthusiastic folks have licensed it. Alas, I don’t really have the time to either properly promote or properly support this as a paid product… so I’ll make it completely free soon.

Ok! So, MIDI!

What is MIDI

MIDI is a control protocol and file format invented 20-odd years ago for music playback on synthesizers. It records all the notes. A .mid file is typically quite small, since it has no sound data in it.

Into After Effects?

Yes! The attached script lets you read a MIDI file into After Effects, and provides keyframes with all the notes.

Install:

1. Download this file.
2. Put the file in /Applications/Adobe After Effects CS5/Scripts/ScriptUI Panels/
3. Run AE, and under window, choose om_midi.jsx, and dock the panel where you like.

Recipe

Here’s one way you could use this script. In the om_midi panel, click the little dot button, and choose a MIDI file. I used one from Wikipedia, BWV 772, one of JS Bach’s 2-part inventions.

Then, with a Comp selected, click Apply.

This creates a Null layer named “midi” with several Slider effects full of keyframes.

This particular MIDI file kept the left and right hands in separate channels, which is nice! The “pitch” effect has keyframes at the beginning of each note with a value of 60 for middle C, 61 for C-sharp, and so on. Here we can see the left and right hands’ keyframes.

A fun way to use these keyframes is to drive the Position property of another layer. I took a photo of my hand, and set the Position expression and Opacity expressions:

Position:
 transform.position + 5*(0,thisComp.layer("midi").effect("ch_0_pitch")("Slider")-60)

Opacity:
  transform.opacity * thisComp.layer("midi").effect("ch_0_vel")("Slider")

So the hand will move 5 pixels for each semitone, centered on Middle-C (60).
Then I rendered the audio as AIFF and added it to the comp. (I used Propellerheads Reason. Yeah… if you’re using MIDI you need yet another set of software to manipulate it.)

And here is the result animation:

More Notes

This is just the simplest usage. A more elaborate deployment might be to export just 1 part of a complex sound-track work as MIDI, to get some of the cues into your AE timeline. With more complex scripts or expressions, you could to much more than just move the hands around.

The script will put multiple keyframes with the same time-value! In the example above, you can see the hands flicker slightly as the final chord begins. Most of the the part invention has just 1 note per hand, which was nice for the demo.

Also, inside the script is a general-purpose MIDI file reader, which you could use for other purposes. I’ve generated Illustrator pictures from scores, for example, full of circles and triangles. Drop me an email or comment if you want help using it! It’s pretty fun.

Update 2012.01.08 Warning about AE CS 5.5 on Mac

Under Mac OS X AE CS 5.5, when you choose the file, it deletes it! This is a CS5.5 bug. (Works fine in CS5.)

Best workaround is to use AE CS 5 or AE CS 4.
Another workaround is:

• make a copy of the file, like myfile_copy.mid
• Select it in the script UI
• recopy the file (selecting it deleted it)
• click apply and all is well.

Useful Things

Yes, indeed, everything old is new again. Just about the time I started using After Effects, I had heard of “Useful Things”, but didn’t really know what it was. Turns out it was… Python Scripting for After Effects! It appears to have been quite well-regarded in the AE community, too. Alas, for whatever reasons, that product seems to have faded, been reabsorbed in the various business permutations that are a fact of life.

Omino Python for After Effects, by coincidence and parallel evolution, seems to resemble that fine product in some aspiring ways.

Grant Munsey

Going back even a tiny bit further, to 2001, we find that Adobe computer scientist Grant Munsey created open source Python bindings for Photoshop and After Effects, as well!

Reading about him, he was a great proponent of open source development, and was a driving force for establishing http://opensource.adobe.com/.

He passed away in 2005; I did not know him. But reading about his long illness, I was touched by this part of his wife’s account:

We’ve been using the mouth stick. It’s a 16-inch rod with a rubber tip on one end and on the other end a U-shaped plastic thing he bites on. He can then trace patterns and point to letters on the letter board — very slowly. I asked him what UNIX command you’d use for getting regular expressions from a text file, and he spelled “GREP”.

And forgive me if I find in this a dark justification for the oft-maligned brevity of UNIX commands.

This plug-in lets you write a script in Python and then run it on every frame. The script can do drawing, access other layers, and so forth. Because sometimes, you just need to write code to get the job done. Omino Python gives you a straightforward way to provide drawing code directly in your After Effects work flow.

This isn’t for everyone; but if you have a little bit of scripting experience, Omino Python should be very easy for you to pick up.

Mac OS X on AECS5 only, for now…

Here’s a little demo.

Here’s another youtube demo, too.

The download includes plenty of documentation, or you can read it right now.

I’ll be posting some tips and examples — there are so many possibilities opened up! — but to break the ice, here’s a simple Omino Python script to do some drawing.

The script in Python. I didn’t know Python before starting the project, but it’s a nice easy little language, and quite popular, so there’s plenty of resources to learn it. It’s not so different from JavaScript or anything else. No semicolons and no curly braces, though! Here it is:

import math
import random

def ompy_main(c):
    ctx = c.layer_out_context

    w = int(c.width)
    h = int(c.height)

    # draw a red circle...
    ctx.set_source_rgb(1,0,0)
    ctx.arc(w/2,h/2,100,0,2 * math.pi)
    ctx.fill()

    # effect parameter controls size
    size = c.floats[0]
    ctx.set_font_size(size)

    # draw a grid of random numbers, spaced by 30
    random.seed(c.frame) # start the random sequence
    for x in range(0,w,30):
        for y in range(0,h,30):
            # random color
            ctx.set_source_rgb(random.random(),random.random(),random.random())
            # random number
            n = str(random.randint(0,9))
            # draw it.
            ctx.move_to(x,y)
            ctx.show_text(n)

And here’s a screen shot showing the output:

Your script can access a collection of parameters — some floats, some colors, &c — and use them as needed. In this case, I just used one float parameter to control the size of the random numbers printed.

This is just the beginning! Read the doc for the full story. Try out the plug-in.

More to come!

If you have not yet read Walter Murch’s book “In the Blink of an Eye”, get thee to a one-clickery and remedy that.

The book is about film editing… I guess. It’s an insightful meander about human perception, dreams, storytelling, and the question: “Why can we understand film-cuts?” He’s intelligent and articulate, and of course he’s a behind-the-scenes guy who worked on Great Movies so he’s got cred too. Really thought-provoking and inspiring.

Alas, I fear he is on weak footing with his recent dismissal of stereoscopic movie-making.

Roger Ebert includes a letter from Walter Murch in a recent column.

His central thesis: 3d movies don’t work, because focus and convergence are misaligned, and 600 million years of evolution don’t support that, so 3d movies give you a headache. That is to say, when the hero-prop thrusts out of the screen til its a foot from your eyes, you need to cross your eyes (convergence) but the actual image is still 50 feet away on the screen (focus). Never happens in nature.

Walter, Walter, Walter! You of all people, who have exploited and shared your deep understanding of just how malleable our percept-system is, should know better! We are more flexible even than evolution requires! By your reasoning a movie closeup shouldn’t work, because it’s 50 feet away, but as big as if it was next to you! It makes no sense. And neither do photographs or cave paintings.

Don’t get me started defending my beloved collection of vintage ViewMaster discs. And why does written language work? Why, why, why.

But it all does. Somehow. And stereoscopic movies are Known To Be Fun.

Every art form has a learning curve. Some art can’t be enjoyed unless you’ve built up to it, learned its language.

Every technology has its artifacts, but its the artists who work with them that determine their ultimate value and efficacy.

And, kids these days, they’ll just keep coming up with new combinations of them. We’ll never keep up.

Still. I’m… sorry that 3d glasses give you a headache.

To do some math recently, I googled a bit more about them. They’re named from Pierre Bezier (1910-1999) who popularized them for CAD while designing cars for Renault. The standard “two-handle” style used by Adobe apps (and most others) is a “cubic Bezier”, because the equation uses some cubes.

To walk a cubic Bezier mathematically, given the four points (two end points, and two intermediate control handles), you can use this Python code, varying t from 0.0 to 1.0:

# given points p0, p0Out, and p1In, and p1, and t varying from 0.0 to 1.0...
a0 = (1 - t) ** 3
a1 = 3 * (1 - t) ** 2 * t
a2 = 3 * (1 - t) * t ** 2
a3 = t ** 3
# calculate x and y
x = a0 * p0.x + a1 * p0.xOut + a2 * p1.xIn + a3 * p1.x
y = a0 * p0.y + a1 * p0.yOut + a2 * p1.yIn + a3 * p1.y

But that’s all tricky. Here’s an intuitive way to visualize just what the heck a Bezier curve really (for really) is:

I did this animation in Python… stay tuned for much more on that front.

Super kudos to bimixual.org for the clear explanation.

Arggh. Developing Pixel Bender kernels and plug-ins, my test files kept behaving erratically. Expression indexes were to blame. Each time I added or removed a parameter, the numbers all shift.

So you see, first enabling the expression produces effect("my_effect")(8). But it depends on the exact order of the parameters!

But effect("my_effect")("param 9") depends on the name.

I think I like the second one better, because I’m pretty good about nailing down my parameter names, but more likely to move them around order-wise.

(See?)

(Show show goes til August 8, worth visiting. On the first Friday of the month, many of the galleries on First Street in San Jose, CA are open late, definitely a nice night out.)

Since I adore repetition, and halftoning, I got to wondering if I could recreate some of the patterns programmatically. The “Omino Stamper” filter runs in After Effects and attempts to do this.

download ==> omino_stamp.pbk, an After Effects filter.

The idea is pretty simple: draw a “stamp image” in a pattern which can be affected by the source image. It’s a little bit like a particle effect, but more mechanical.

Here’s the controls and few examples, which look nothing like Hawaiian shirts.

A quick rundown:

• The pattern- settings adjust the stamping grid
• The stamp- settings adjust orientation and size of the stampimage image
• The stampOverlaps setting controls how many nearby stamps are computed for each pixel; slows down the render a bit but is necessary for closely-spaced stamping. (If you see missing corners and such, increase this setting. (Those of you familiar with Pixel Bender will immediately apprehend why this is so.
• The affectsStampSizeAmount, affectsStampColorAmount, and affectsStampRotationAmount settings control the halftoning features of the filter.

Here’s a basic stamp:

Next, we adjust the bricking a little, to make it less square-y:

And let the color of the underlying image affect the stamp color:

How about affect the rotation, instead of the color? Kinda wild:

Or back to basics, let the underlying image affect the stamping-size:

Here’s a festive little animation playing with the effect a bit, and does include a Tiki god or two.

download ==> omino_stamp.pbk, an After Effects filter.

Enjoy!

Here’s a cute one. Nothing deep or advanced, but it was fun. It’s a way to get a very simple and cheap “rain” in After Effects.

1. Take a tiny bit of Noise, and blur it in one direction with Fast Blur.
2. This makes very, very dim “streaks”. Use Threshold to make them visible again.
3. Fast Blur it a little in both directions to make the edges smooth again.
4. Rotate the whole layer, for angled rain.

Easy peasy!

Here’s the AE setup for it. Trivial! Small adjustments of the parameters can get all sorts of interesting results.

What about CC Rain?

Well you know, apart from the joy (cussedness) of doing it the hard way… CC Rain makes relatively slow well-defined rain streaks. Depending what look you like, combining CC Rain with the more random movement described above is pretty nice, too.

If you like, here’s the self-contained tiny AE project. ==> just_rain.aep

The new link is http://omino.com/pixelblog/omino-ae-plugins/, and also appears as a “Page” in the blog nav column, and should be much clearer.

Always doing things the hard way. Needed a wheel with some symmetry, like so:

How else to do it than by drawing a circle with some blobs, and then treating it with… a handwritten pixel bender kernel:

I started describing its controls, but wouldn’t it be more fun to just try it out? Below is a slightly reduced version of the Pixel Bender kernel running in Flash.

Give it a spin! Try the parameters, or click Scramble a few times, or Go, to let it choose random parameters.

There’s no shortage of vaguely-trippy image manglers, these days, but that’s no reason not to indulge.

Just recently, Dale Bradshaw posted a rounded-rect pixel bender plugin. Pretty nifty!

It got me thinking, What about other rounded-corner polygons? It was a bit of a puzzle. As with all Pixel Bender plugins, the question is, What color is this pixel? How does a given pixel know if it’s inside a rounded-corner pentagon or not?

I stuck to regular and stellated polygons to start. One solution goes like so:

• Divide the plane into pie-slices, one for each edge of the polygon.
• For each point, decide which slice you’re in.
• Decide if you’re inside or outside the edge.
• For the rounding… decide which corner you’re nearest
• Are you in the arc of that corner? If so, decide if you’re inside the rounding-radius.

Well, that was a bit of obsessive fun. Here’s a screen shot, including the parameter controls:

And here’s a little demo of it.

download: ==> omino staragon 32 <== a pixel bender filter

There was a flurry of interest in "chromatic aberration" a while back, like here. I’d actually played with it a bit, simulating lens-effects, but only now have gotten around to weighing in on it.

The implementations I’ve seen work by splitting out your RGB and moving them around a little bit independently.

Here’s my weigh-in: Come on, people! The spectrum has more than three colors!

I find that five to seven is about right. I’ve implemented this combined with refraction into a pixel bender plugin.

Refraction happens when a ray of light changes its direction as it passes from one substance to another, if they have aaah, varying, that is, if they have different, um, refractive indexes. And that’s how aaah magnifying glasses work. See.

It looks like this.

The blue lines are rays of light moving up, or cast-sight-rays going down. It’s all very technical.

But I’ve got this Pixel Bender filter, right?

The filter takes in two images: a bump map (the refracting surface) and an image to view through the refraction. Here’s a bump map:

And here’s a source image:

Those chairs are known as “Chadwick Modular Seating”, from Herman Miller, designed by Don Chadwick, who later designed the Aeron chair, and that room hasn’t been that empty for, like, six years, after my girlfriend moved in and filled it up with shoes and stuff. So anyway.

And here’s the image, through the omino_glass Pixel Bender filter:

Now the fun part. Chromatic aberration happens when different colors are refracted by different amounts. Here’s the same image with just a touch of chromatic aberration applied:

Livens it up a little bit, yes?

The “flat” parts of the image, under the non-sloping parts of the bump map, appear undistored, and uncolored. But the distorted parts of the image have their colors splayed out a bit.

That’s chromatic aberration, comma, simulated.

By the way, you can get this effect in After Effects using CC Glass and overlaying multiple tinted copies, with slightly different settings for Height, and adding them back together. But that’s a lot of layers and settings to juggle; my pixel bender filter does it all in one at 32bpc instead of 8.

Here’s a test grid set with no basic refraction, and lots of chromatic aberration. This leaves the central green portion of the spectrum centered on the original image.

The inset image is the bump map.

We can see how omino_glass breaks the spectrum up into seven regions. It’s arbitrary, but I like the look.

And here’s a little demo showing the filter in motion, animated in After Effects, out on the ‘Tube.

download: ==> omino glass 32 <== a pixel bender filter

Other chromatic aberrations of interest, from some of my favorite blogs:
ae-tuts
maltaannon
satya meka

Time marches forward. Computers are faster, hard drives and screens are bigger, cameras are smaller.

My usual settings have grown from 8 bit, 640×480 to 32 bit 720p. (Yeah, I’ve lost my fear of nonsquare pixels.)

Adobe just announced After Effects CS5, and I’m happy to report that the Omino After Effects Suite is fully ported for Mac OS X, 64-bit, and getting ready to roll.

And they’ve started their migration from humble 8-bit processes to glamorous 32-bit floating point processes, as well.

Tragedy

The great tragedy is that CS5 broke backwards compatibility with CS4 plugins. Oh, there were Reasons, oh yes, there always are. And, oh, they’ve made it relatively easy for developers to recompile, which I’ve done. (Worked like a charm.)

But between Apple’s fickleness (68k, powerPC, Intel) and, now, this… there’s a trail of plugin corpses. Great sadness.

Some of my favorite Plugins don’t even exist for AE Intel Mac. Actually, the only ones I’ve paid for… WalkerFx’s stargate, and dvGarage’s dvMatte Pro. How I do wail!

Rays of Hope

But are things, overall, getting better? Oh yes, much better.

My CS5 plugins are Mac only, for now.

The Mac/Win CS4 versions will remain available. Or should I say, will remain on display in the Marketplace that all may witness their demise and death, their only crime having been to be compiled at the wrong place at the wrong time.

http://omino.com/sw/.

addProperty() bug

When adding several effects, each addition invalidates the object variable references to earlier ones. Here’s a code fragment which shows the problem and the solution.

var comp = app.project.activeItem;
var layer = comp.layers.addNull();
layer.name = "null_layer";

var slider1 = layer.Effects.addProperty("Slider Control");
slider1.name = "s1";

var slider2 = layer.Effects.addProperty("Slider Control");
slider2.name = "s2";

// At this point, slider2 is valid, but slider1 is mysteriously not!
// Any action or reference to slider1 will cause an "invalid object" error
//
// What can we do?
//
// Fortunately, they have names by which we can recover them

slider1 = layer.Effects.property("s1");
slider2 = layer.Effects.property("s2");

// Now they're both good to go.

setValueAtTime() Gets very slow!

If you do a whole lot of setValueAtTime() calls to set keyframes, the script will run very slowly. Fortunately, you can just call setValuesAtTimes(), the plural form, to set many at once, which is much more efficient! Makes the minutes seem like seconds, Captain.

// this will be very slow, if myData has more than a few dozen items
for(var i = 0; i < myData.length; i++)
	prop.setValueAtTime(myData[i].t,myData[i].v);

// but if we build up our arrays first...
var timesArray = new Array();
var valuesArray = new Array();
for(var i = 0; i < myData.length; i++)
{
	timesArray.push(myData[i].t);
	valuesArray.push(myData[i].v);
}
// and set them all at once
prop.setValuesAtTime(timesArray,valuesArray);

// it will go lickity-split!

(Thanks creative cow thread!)

But I think I can articulate two well-considered features that would boost its utility quite generally.

Feature Request 1: Foldering

When working with many layers, it would often be nice to group several of them together. To do this, I’d like to create a folder for them. This would help manage the grouped layers visually, and collapse to reduce them to a single line item.

You’d be able to apply effects to the folder. Maybe it’s called “groups”.

This is very similar to a precomp, of course, but you can work on the keyframes locally, instead of switching up and down the tree or using a split view.

Feature Request 2: Exportable Rigging Properties

Precomping is great, but it still doesn’t let you “rig” and “instance”. In my particular case, I’ve got two “claws” animated. They’re identical, but need to animate differently. Today, I need to duplicate the layers (either in the comp, or as separate precomps). Which is a shame, because I’d like to fiddle with the claw design, maybe later, and have my changes affect both!

So, this feature lets you expose a keyframable property on the comp, so that when it’s nested you can control it from the parent comp.

You can, if you’re overly clever, use Time Remapping to accomplish this a little bit. But I’d rather see clearly named “rigging” properties on my comp, itself, to animate.

(You could imagine also being able to add rigging properties to a folder, or maybe even any layer. This would be the same functionality as the “Slider” effect, but maybe tidier.)

As well as sliders and checkboxes, you could export “layer” properties, which pipe in a layer of the parent into the child comp. This lets you create an effect out of a comp. Presets can do this, a little bit, but in a flat, non-tweakable non-instanceable fashion.

I’ve heard one AE developer refer to a variation on this idea as a “Capsule”. The idea he described would require (I think?) you to save a comp into a separate file, before being able to reuse it. I think one of the brilliant project features of After Effects is that you get multiple timelines within one project. I like the One Big File workflow! (I wish 3d apps had this; as far as I know, they all work only on a single timeline per document.)

Miscellany

It would be nice to drop in a “reference” layer, that could repeate a different layer within the same comp to a different layer order. This would need to be post effects to be useful. It would let you perform different treatments on the same source… again, without a precomp.

It would also let your manage a folder, and still retain flexibility on its layer order.

To conclude…

After Effects is already quite strong in terms of “instancing”. That’s practically its main power. But it fails for purposes much beyond “tidiness”. “Rigging Properties” addresses this key omission.

Photoshop recently got “foldering”, and lets you set transfer mode and transparency on a group of layers. This is grand! I want it for After Effects.

This is a rendering simulating an image projected onto a simple 3d scene. There’s nothing too exotic about it, except that the projection was done in 2d, in After Effects.

And… here’s a moving sequence of the same scene. With old family movies.

The usual way you’d do this is by rendering a movie, taking it into your 3d program, and projecting it onto a scene through a light source.

For my current project, I needed this effect, but wanted a way to work in After Effects. I did this for workflow reasons: my projection content was all AE authored. But it also turns out to save render time. More than a little.

The trick was to render the scene in 3d as a coordinate-map, in Red and Green. I used Modo, and the projection mode is called “Front Projection”, from a spotlight or camera. I projected a red-green ramp onto the scene.

But we’re going to use the red and green values as a projection function. Changing the shader to use unattenuated (“luminous” @ 1W/steradian in modo) accomplishes this. We’re rendering geometry, not optics.

Then, I wrote a simple Pixel Bender kernel to use the red and green pixel values as coordinates to draw from the source projected image.

// by david van brink / poly@omino.com / 2009
// http://omino.com/pixelblog/
kernel rg_projection
<  namespace : "omino";    vendor : "omino";    version : 1;
   description : "uses red/green from one image to map another"; >
{
    input image4 src; // Red-green mapping image
    input image4 ref; // image to project
    output pixel4 dst;

    parameter float imageXSize;
    parameter float imageYSize;
    parameter float imageXOffset;
    parameter float imageYOffset;

    void
    evaluatePixel() {
        pixel4 a = sampleLinear(src,outCoord());
        float r = a.r * imageXSize + imageXOffset;
        float g = a.g * imageYSize + imageYOffset;

        dst = sampleLinear(ref,float2(r,g));
    }
}

To test the Pixel Bender kernel, I ran a reference grid through the red-green ramp.

The first one shows gamma correction on the ramp image in After Effects. Under “Interpret Footage”, be sure to turn on “Preserve RGB”.

The second one reveals that Photoshop’s default ramp is some sort of s-shaped modified linear function. Creating a custom gradient with more stops along the way helped get the third, which is Good Enough. I went back and redid the scene with the improved red-green gradient.

And of course, use 32-bit color throughout. 16-bit works ok, too. 8-bit showed definite Squarifying in the projection, though.

To reintroduce the optical nature of the projection, back in After Effects it’s multiplied by a normally rendered image and, because I still think it’s pretty neat idea, an ambient occlusion pass as well.

And there you have it! 3d projections done all in 2d.

This one is a little experiment using After Effects’ spotlights on still images which have been rendered with similarly-located light sources.

Here’s one of the several still images.

And here’s a short movie showin a little more of the procedure, and some results.