Image Manipulation: From Stack to Nodes

(Meta: I am posting after weeks.. I was away from the Net, for some time)

Those who have used programs like GIMP or Photoshop, would know that operations on images are invariably performed in a stack fashion. Seriously, nothing could be more annoying. For eg. suppose that I adjust the sharpness, and then do many more operations after that; and then the boss comes and says he’d like more sharpness to start with. The only way to revisit the old operator, is to empty the stack by keep doing undo. What a waste.

Contrast this (no pun intended) with what is seen in compositing software. For eg, Blender’s internal compositor. There, the fundamental unit is called a node, and it represents some operator (eg. contrast adjust, or Gaussian Blur). Basically, you connect the output of one node as an input to the next one, eventually building an “assembly line” of nodes, each node doing a particular operation on the image. For example, one can get a hazy glow effect by putting the original image through a blur node, then stepping up the brightness levels with another node, and then mixing this with the original:

The node-based approach has several advantages:
1. Even after you add more nodes, you can still scroll left and edit the previous nodes, or even change their setup entirely. The stack-based approach fails miserably here.

2. One can perform more complex operations, involving “previous” versions of the image. For example, in the node setup shown above, we mixed the changed image with the original one. A stack-based approach cannot allow simultaneous access to the original as well as the manipulated image (unless you took the trouble to save them as separate layers). Just like code reuse, this is an instance of resource reuse: when you apply several operations on an image, you should be able to reuse the intermediates. The stack-based flow effectively discards the intermediates.

3. We often have to do the same long set of operations over and over, for several images. The node-based approach makes this very easy: just duplicate the entire limb of your node setup, that corresponds to those operations. Or even better, you can merge those nodes together into a single “node group”. Node groups, in other words, represent an arbitrarily complex series of image operations, as a single entity that can be duplicated/relocated with ease. Of course, you can always edit the node group itself, if you need to.

(Photoshop does have so-called “adjustment layers”; but it is a sham, compared to all this.)

One thing to note, though, is that the requirements of an image manipulation program, are slightly different from those of a compositing software. Even so, many basic operations performed are very similar in nature. I think that the future of image manipulation is definitely moving away from stack-based editing, to node based.

4 responses to “Image Manipulation: From Stack to Nodes

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s