Shake is a collection of image manipulation engines, like compositing or warping.
Each engine can be driven by a series of different commands, called interchangeably
nodes or functions. For example, Gamma is a node to change the gamma
of an image, Pan is a node to pan an image, etc. Each node usually has
a series of parameters in it, for example, how much to pan in the left and right,
up and down, etc. The interesting thing about Shake is that the nodes and their
parameters can be edited either in the Interface (Graphic User Interface, or
GUI), a script, or from the command line. There is no difference to the composite
how these nodes are called, but each method has its advantages or disadvantages
in terms of workflow. This is a brief outline of how the workflow goes for each
method, and the advantages to using each method.
These outlines are meant to indicate the workflow alone. See related tutorials
to get the actual specifics.
Reasons to use
the Interface
95% of all compositing trees are probably going to be made in the GUI. Its
the main tool for editing, animating, tuning, and arranging nodes. Because it
displays many types of information simultaneously, it is the method usually
used when anything gets even mildly complex.
Interface Workflow
- Images are read in from various directories.
- These images, as represented by the nodes, are arranged in a compositing
tree, with color-corrections, layering commands, keying functions, etc.
- The parameters of the nodes are tuned with interactive feedback in the
viewing windows
- Once finished, a FileOut node is attached to tell Shake where to
write the output image. You can use as many FileOuts as you want, placed
anywhere along the tree.
You can render from the interface by choosing the FileOut, and then
hitting the flipbook button, or...
- The tree is saved out as an text script.
- From the command shell, or from your own batch rendering system, the script
is then executed, and the output image written to disk.
Reasons for using
Scripts
You can do script-based composite by hand-typing a script on your own, modifying
a script written by the interface, or by saving a string of batch commands as
a script. For those of you who are more accustomed to using an interface, and
may be discouraged by scripting or by typing commands in the command line, keep
in mind that both of these quite often have substantial benefits for specific
tasks, and learning them is worth the effort.
The script has several appealing aspects to it.
- First of all, you don't need an Interface license to edit the script, you
only need the less-expensive render license to execute it.
- Its much easier to change input and output file paths in a text editor.
For example, you may want to point a filepath from a low-res directory to
a high-res directory of the same files. You don't need to actually load the
script up in the interface. For you UNIX people, you can use UNIX-style shell
commands like sed and grep to examine your scripts without even opening it
up.
- Although the interface can be set to turn off its updates, just the act
of calling the interface, and loading a script will involve browsing around,
and perhaps even loading up 2k plates into Viewers. If all you want to do
is modify a specific Gamma value from 1.02 to 1.03, it faster to do it in
a text editor.
- You can organize repetitive tasks using a different organizational logic.
For example, I created each function icon that the interface uses with a Shake
script. This means I had about 150 input images and about 100 output images.
Using a text-based organization, I was able to organize the script into distinctly
separate blocks. To be honest, its much easier than accessing this information
in a graphic interface.
- Finally, a real key reason to use scripts is that they essentially use the
C programming language, opening up your script to an entirely different level
of control to programmers. For example, you can create if/then statements
or for loops, or call other external C libraries to be used in your scripts.
Shake is also a run-time compiler, so you don't even need to use a separate
compiler; just render it with Shake.
Scripting Workflow:
- FileIns are created at the top of the script, then macros, followed
by similarly grouped functions.
- The scripts is saved, and tested in the command line. The last node is
evaluated, plus any node called to by a Monitor or View function.
- When all is satisfactory, FileOut commands may be added to the script,
or added in the command line.
Reasons to use
the Command Line method
Every function that can be done in the interface can also be executed in the
command shell, usually in what is known as a tcsh (pronounced "t-shell"). Shells
are standard in UNIX, and for NT users, we recommend downloading the tcsh port
for NT available on our website. It's not ours; it is shareware that we carry
for our clients. The command-line is perfect for when you know exactly (or almost
exactly), what you want to do, and it's not very complicated. It's great benefit
is speed. If you just want to take 4k resolution plates and make video-res copies
with a change in gamma, it may be easier to type that out than to actually fire
up the interface and connect all of the nodes.
Some common command line uses:
- Resize, rotate, crop, or flip/flop images from scans
- Add sharpening filters as you resize elements upwards
- Change gamma on an image and sending it to an accom
- Change image file formats
- Place the luminance of an image into its alpha channel
- Load images into a flipbook
- Render scripts
- Check a rendered 3D element over a background plate
- Renumber and rename files.
- Compare two images.
For these reasons, you see Shake commonly being used not just for traditional
compositing functions, but also in a supporting role for 3D and I/O departments.