Andrew Benson

In third installment of Jitter Recipe Collection, there are more snacks for the Patching Enthusiast! This Jitter Recipe 

 recipe posted recently to create a realtime 3-D anaglyph image.

The mechanics of this patch are very similar to the RagingSwirl patch, applied to video processing instead of OpenGL geometry. In this example, we are actually distorting and manipulating a 3D matrix, but only viewing one slice of it. The jit.charmap is used to turn our 1-plane matrix into a full color image.

Using the "bot" subpatch, our matrix is continuously drawn into with the jit.poke~ object.

This is then rotated across 2 different dimensions using a combination of jit.dimmap and jit.rota (see RagingSwirl).

Next, we take one 2D slice of the larger matrix for display using the "srcdim" messages.

This is then converted to a 4-plane matrix and colorized using jit.charmap. By using an upsampled color map, we are able to constrain the palette, and decide between a smooth, cloudy look or a flat, hard-edged look.

This demonstrates a way to generate an alpha-channel based on an analysis of the video. Here we use the amount of movement (difference) between consecutive frames, and then impose a threshold to decide what pixels will be visible. The effect resembles that of a degraded digital video signal, and can be used to generate all sorts of pixel debris.

The most important aspect of the processing is the generation of an alpha mask. To do this we first convert our video stream to grayscale using jit.rgb2luma.

The matrix is then downsampled using random "dim" messages, generated by the random object.

This is then compared to the previous frame using jit.op @op absdiff to get the absolute difference between the two. Note that we are taking advantage of the trigger object to perform this slight of hand.

Once we have generated our difference map, we then use jit.op @op > to create a threshold. This means that it will turn on any pixel that has changed more than the threshold. This will then serve as our alpha mask, but passing it into the first inlet of the jit.pack object.

Once our alpha channel has been packed in with our live feed, this is then blended with our current image using jit.alphablend. The resulting image is then fed back to be blended with the next frame using a named matrix.

I get a lot of questions about dealing with text in video patches. Whether you are using text as labels, titles, or subtitles, you will generally want it to be in the foreground. In order to do this successfully, while maintaining the transparency of the jit.gl.text2d's bounding box, you must impose a drawing order.

The key thing to this patch is maintaining the render order. To do this, we turn the @automatic off for all of our gl.objects, and then use the trigger object to bang them in sequence.

Using the jit.str.fromsymbol object, we route the text output from the textfield and convert it to a jitter matrix for rendering single-line text.

The jit.textfile object is very useful for dealing with formatted text. Simply double-click the object to bring up a text editing window.

By turning on @blend_enable for the jit.gl.text2d object, we make sure that only the text itself is displayed.

To generate the shadowed text, we actually render the text twice - once in black, and then offset in white.

This example is a simple patch that demonstrates a way to generate looping effects with jit.qt.movie. This is very useful for those who are interested in working with looping videos, and creating realtime editing patches. With a little tweaking, this patch could serve as the basis for more complex playback procedures.

First, we need to set jit.qt.movie's autostart attribute to be off, to prevent it from playing back the movie file automatically.

The key to understanding this patch is the use of the accum (as a counter) along with the modulo (%) operator. This allows us to count loops.

One tricky bit is the use of the route object to obtain the framecount of each movie loaded into the jit.qt.movie object. This sets the modulo size of the entire movie, which makes sure that we always send frame numbers that are within the range of actual frames in the movie.

When the stutter toggle is turned on, a shorter loop of numbers is generated that is added to the current frame number.

These numbers are then sent to jit.qt.movie using the "frame" message.

This patch takes an audio signal and generates a cascading, lumpy surface. Using some simple expressions, this surface is then distorted to create a pregnant lump. Environment mapping creates a liquid-like reflective surface.

We take the vector of audio grabbed by jit.catch~ and render it to a single row of a matrix. This matrix is then stretched down slightly and fedback. This generates the cascading effect.

We then flip the matrix using jit.dimmap and use jit.expr to create the coordinates of our OpenGL shape.

By taking the sin of the x and y coordinates, we generate a rounded lump across the z-coordinates.

Once we have generated our figure using jit.gl.mesh, we use @tex_map 3 to apply our texture as an environment map. Lighting is enabled by turning on @auto_normals and @lighting_enable.

Our texture is generated using a similar technique to that used with our sound vector.

This example shows a good way to generate stable timing for automation parameters, despite the fluctuating framerates common to Jitter. By using the CPU clock, we ensure that the flow of the animation is steady regardless of framerate. It also shows a simple way to use autopattr and pattrstorage to manage many parameters at once.

In order for autopattr to see our UI elements, we'll need to name each of these objects. To do this, we simply select the object and hit Command+' (mac) or Control+'(windows) and enter a name into the field.

Once we have set up our named UI objects, we can then store presets using the pattrstorage objects.

Because cpuclock counts the number of milliseconds since Max was opened, we will need to constrain the range of this output to be useful for us. To do this, we use a modulo (%) operator. The output is then fed into the function object, which outputs the value at that x-location of the curve.

This patch utilizes the handy interpolation function of pattrstorage, which allows you to recall in-between states by sending floating-point values.

This same technique could be applied to any number of parameters for any number of OpenGL or other Jitter objects for a complex animation setup.

One of the most straightforward ways to do video sensing with Jitter is to perform frame-differencing, which gives you a reading of the amount of movement. Using a couple of basic Jitter objects, we can map the amount of motion in a scene to a variety of synthesis parameters.

First, we convert our video stream to single-plane using jit.rgb2luma. We do this for simplicity. You could also try performing these calculations with all of the individual color channels for more complexity.

To get the difference between consecutive frames, we use jit.op @op absdiff. This will show us the amount of movement between frames. We then use a jit.op to do apply a threshold. This will give us a binary image.

This image is then fed through jit.slide to remove flickering and smooth out the data flow.

The jit.3m gives the mean value of all of the cells in a matrix. If you remember your arithmetic, you will know that the mean is derived by adding all elements together and then dividing by the number of elements. We take the inverse approach to calculate the total number of white pixels in our image.

This is done by first multiplying the mean output by 327,200, which is the total number of pixels in a 640x480 matrix. Since the value of white in char data is 255, we must then divide by 255 to get the number of white pixels.

Once we have this number calculated, we can use it to drive the synthesis parameters of our audio stage.

In third installment of Jitter Recipe Collection, there are more snacks for the Patching Enthusiast! This Jitter Recipe "AnaglyphRender" builds on the "RenderMaster" recipe posted recently to create a realtime 3-D anaglyph image.

Download the Book 3 Max 4.6 patches and the Max 5 patches

All the books in this series:  Book 1, Book 2, Book 3, Book 4 

Performing transformations on a 3D matrix

Generating video-synthesis with audio signals

Using the alpha channel to do complex blending effects

Generating timing effects with frame messages

Using an environment map to create reflective surfaces

Using geometrical expressions to create shapes

In third installment of Jitter Recipe Collection, the Jitter Recipe “AnaglyphRender” builds on the “RenderMaster” recipe posted to create a realtime 3-D anaglyph image.

jitter-recipes-book-3

these three books are absolutely amazing. thank you.

Having a look at these recipes made me feel as if I was playing 

Having a look at these recipes made me feel as if I was playing Duplo and Andrew was playing Lego Technic. Amazing. Thanks for sharing.


hi . how to put a video plane behind (for exemple) your beautiful open gl thing in the "Render Master" patch ? i'm having issue with a similar ...thing.

Hi Moté, it would probably be easiest to help if you post what you have in the forums and we'll try and get you going.

Thank you, these exemples realy helped me to learn how to use jitter...

Hi. I have been exploring recipe 36 tiny videos trying to slow down the animaton and also dividing the screen in less squares. I have gone trough most tutorials and tried many things. But unsuccesfully! Help will be appreciated.

This series is spectacular - thanks Andrew.

Wondering if there is an earlier source for the Paramination audio synth, or if you came up with it for this series. Same question with the nice Squelcher synth, recipe 20... Thanks!

Paramination audio engine is based on an old synth patch I started making over and over again when I was in art school. Squelcher is a toned-down version of a pretty wacky and loud sequenced synth patch JKC and I built one lazy afternoon in the first Clementina St. office. Various versions of that patch have floated around for years.

Hi Jean-Francois,
Paramination audio engine is based on an old synth patch I started making over and over again when I was in art school. Squelcher is a toned-down version of a pretty wacky and loud sequenced synth patch JKC and I built one lazy afternoon in the first Clementina St. office. Various versions of that patch have floated around for years.


Jitter Recipes: Book 3, Recipes 26-43