This tutorial focuses on data capture and playback – in essence, we will be performing sequencing. However, unlike the sequencing found in the MIDI Tutorials, this is sequencing of arbitrary data (mouse movement, in this case). We will be expanding on our use of
coll, this time collecting as well as reproducing data for an interesting drawing patch.
The heart of many performance tools is the ability to capture and play back movement, whether motion capture data, sensor data or mouse movement. This tutorial will present the basis for capture and playback systems, and will introduce a few interesting design patterns as well.
Take a look at the tutorial patcher. This is a fairly complex patch, and the whole thing serves one purpose: capturing mouse movement and turning it into an interesting drawing. The interesting thing is that while receiving mouse movements and drawing the picture, the patch is also “recording” the movements. Because this patch depends on regular timing regardless of other computer activity, you may want to turn on Overdrive under the Options menu.
An important hint: you don’t want to interact with this patch using the mouse, since it will tend to mess up your drawing. Rather, notice the
key object-based section just above the
lcd object: this maps three keys (space, “r” and “p”) to three patch functions (“clear”, “record” and “playback”). To begin, hit the “r” key (lower-case is important!) to begin the recording process. Now, move you mouse around the screen – looping and large movements are especially effective. When you are done, hit the “r” key again to turn off recording.
Now you have an interesting, script-like drawing on the
lcd display. Hit the space bar to clear the display, then hit the “p” key to begin playback. You will see the drawing occur: not only was the drawing captured, but the actual mouse movement (and timing) were captured and reproduced.
There are three
coll objects in this patch, but all of them refer to the same data: the data in a
coll named
thegest. The copy at the right is most convenient to access, so double-click on it to reveal the captured data. The contents of the
coll shows our movement being tracked and captured in 20 millisecond intervals. Let’s look at how this capture happened.
The
RECORD section of the patch, at the top-left, is all started with the big red
toggle object. When it is turned on, it resets the patch (via the
sel 1object connected to the right outlet of the
trigger), then starts a
metro that fires every
20 milliseconds. This determines the “sampling rate” of the mouse tracking, and also serves as a trigger for the other objects. The
metro sends a
bang message to two objects: a subpatcher (the scaled version of
WTHITM that we've been using) and an
int (abbreviated "i") object.
The
WTHITM abstraction should be familiar by now – it tracks the current mouse position, and outputs a value set (X and Y coordinates) scaled to the range given as arguments. In this case, it means that the output of the subpatcher will be in the range of
0-
320 and
0-
240, and the subpatcher will output a value any time it receives a
bang message. In order to provide immediate feedback, the output of the subpatcher is sent to a drawing subpatcher that generates drawing commands for the
lcd object.
The
int object, and the
+ object connected to it, performs a useful function. Incoming
bang messages will output the current value (as seen by the
number box). However, the output value will also go to the
+ object, which will add one to the value and store it in the right inlet of the
int, waiting for the next
bang message. The result is that every
bang message will output a value, but also increment it by
1 – sort of like a
counter object, but with no upper limit. This is a useful way to get an ever-increasing number for situations where you don’t know what the limits might be.
The values from these two objects (the current count and the scaled X and Y positions) are assembled with a
pack object and then sent to the
coll object - the first value in the list (the current count) acts as an index, telling
coll to
store the remaining values at that position. As a result, the
coll acts as a data recorder, taking the indexed values and storing them for later use. The collection of data continues until the record function is turned off, either by clicking on the red checkbox, or by hitting the “r” key.
Take a moment to look at what the
select object connected to the recording
trigger does. When the recording is begun, a
bang gets sent to a second
trigger object that, from right to left, turns off the "play"
toggle box (stopping any playback), sends a
clear message to the
lcd, erases the contents of the
coll (with another
clear message), and zeroes the
int object to reset the index counter.
The playback part of the patch, at the lower-left, mirrors much of the recording section, except it doesn’t to any mouse tracking. Rather, it just requests indexed values from the
coll named
thegest, and uses the same drawing patch to recreate the mouse drawing movements. It is able to use the same incrementing integer technique used in the record section; this has the benefit of not requiring an upper limit to be defined, but a downside of never stopping or looping on its own.
Since the record function didn’t “timestamp” the captured data (it just indexed it with the output of the integer object), it means that we can manipulate the playback of the drawing by altering the speed at which we request the
coll’s content. The easiest way to do this is to change the speed of the playback
metro.
Unlock the patch and add an integer
number box in the area of the playback section. Connect its output to the right inlet of the
metro (which controls the output interval). Enter 2 into the
number box, then hit “p” for playback. The drawing will occur as before, but will run 10 times as fast. Stop the drawing (hit "p") and change the
number box to 40, hit the “p” key again, and the drawing will run at half speed. As you can see, this data capture technique gives you a lot of flexibility at playback time.
Once you have an interesting data capture, you will probably want to save it for later use. The
coll at the far-right (outlined in blue) shows the simple method for saving and retrieving
coll contents; a
read message will allow you to import data from disk files, while a
write message will take your captured data and store it to disk. You can append an actual file name and path to the message if you have a specific file to read or write, while a read/write message with no arguments will open a file dialog for file selection.
Make a few drawings and save them using the
write message to the
coll on the right. If you read them back in (using the
read message), you will be able to play back your saved drawings. Notice that the data files created by
coll objects are simply text files; you can open then in any text editor or import them into another program for viewing or manipulation.
In this tutorial, we’ve seen how to use the
coll object as a data collection device; we've also learned how to design a counter with no upper limit. We’ve also seen how the
coll can be used for disk storage and retrieval, allowing us to save and reuse our captured data. Finally, this patch is a good example of a single data set being used by three
coll objects, a method for data sharing that becomes very useful with large patches.
See Also
Name |
Description |
coll |
Store and edit a collection of different messages
|