In Theory
In Theory
Embedded Files
A proper compositing workflow can be quite a long topic. For the purposes of architectural visualization, I will keep this simple and straightforward and will illustrate what are the most important things to keep in mind when working with Fusion.
Linear Workflow in Fusion follows the exact same principle and has the exact same purpose as described previously for 3ds Max - we want all calculations to happen in one unified Linear space. Not keeping track of different Gamma inputs, we risk improper merging of alpha channels, incorrect color transforms, films grain issues and color banding. The values we worked so hard to light and shade properly will be muddied and frustrating to work with if we don't respect a correct linear gamma workflow in post.
Apart for keeping track of Gamma, in compositing we also need to watch out for image bit depth. Images need to be rendered in the correct bit-depth and image formats, if not, we risk inefficient I/O speed and insufficient metadata in order to work linearly, bringing us back to the same issues mentioned before. Here is how a correct workflow for compositing should look like:
Floating point image formats like EXR, HDR and Linear TIF are already Linear, however, other formats like PNG, JPG, TGA have an embedded sRGB Gamma curve. This is where we need to transform all these sRGB curves to behave linearly, so that our compositor can do all the operations evenly and reliably across multiple image formats. The image below illustrates some of the possible problems one might encounter when calculations are done in sRGB space.
An example of Linear merging of two sRGB images vs sRGB merging. For linearization, a Gamut node needs to be used after every non-linear input. You can see that with the sRGB merge on the right the alpha doesn't look correct and colors become muddy and over-bright in transition areas.
As mentioned, with compositing aside of Gamma, bit depth is also an important factor when it comes to correct calculations. Below you can see an example of two sets of images merged with different bit depths.
This image is made up of two Background nodes merged together with an Ellipse mask. On the left, both Backgrounds have Depth set to float16 while on the right both are left at Default, which is the same as 8 bit. The color banding in the resulting merge on the right is very prominent.
In Practice
In Practice
To work in Linear Workflow, all Non-Linear inputs need a Gamut node applied right after their Loader. This Gamut node removes the embedded sRGB curve and linearizes these images. Furthermore, all images must have the same bit depth, so the ones that do not match need to be converted through their Loader node. Background nodes also need to be set to the needed bit depth as well. This is usually 32 ot 16 bit floating point. After all calculations are done, a Gamut node is put before the Saver node. This Gamut node adds sRGB Gamma back to the image and embeds it when outputting so the image can be viewed correctly afterwards. To preview our work with the correct Gamma throughout the compositing process, we use Fusion Gamut LUT in the image window.
Gamma Management
Gamma Management
Non-Linear Inputs
For Non-Linear images, a Gamut node needs to be added after each Loader.
Change Source Space to sRGB
Make sure Remove Gamma is turned on
Outputs
After calculations are done in Linear space, a Gamut node before the Saver does a conversion to sRGB.
Change Output Space to sRGB
Make sure Add Gamma is turned on
Gamma can also be added/removed through Loader and Saver nodes, however, Gamut nodes help visualize what exactly is happening. When a junior artist opens a composition done in Linear Workflow, it is much easier to understand what is going on. This is why working with Gamut nodes is the recommended workflow.
Bit Depth Management
Bit Depth Management
Images Bit Depth
Images that do not have the correct bit depth (usually dictated by the 3d render) need to be converted through their Loader node.
In the Loader node switch to the Import tab
Change Depth from Format to desired one (float16 or float32)
Background Nodes Bit Depth
Background nodes are created like 8 Bit images by default, therefore they also need to be adjusted.
In the Background node switch to the Image tab
Change Depth from Default to desired one (float16 or float32)
Bit depth can also be changed via the Change Depth node for a more visual workflow (following the same logic as explained above about why to use Gamut nodes instead of changing Gamma within Loaders/Savers).
Viewing
Viewing
To properly preview our composite, we need to use an LUT in the viewer the same way we do in the V-Ray Frame Buffer.
Once an image is loaded into the Viewer click on the drop-down arrow next to the LUT button
Choose Gamut View LUT
Click on Edit... to change the settings
Set Output Space to sRGB
Make sure that Add Gamma is checked
Click on the LUT button to enable the view transform
Color Management
Color Management
It's important to note that Color Selectors in Fusion work with sRGB values but colors are actually converted to Linear automatically behind the scenes. When selecting a particular color it must be viewed through a Gamut View LUT to show correctly. This is done intentionally as Fusion expects its users to work in Linear Workflow by default and it saves one step of the process of converting sRGB space to Linear space.
When the LUT button is switched on the color in the Color Selector matches exactly the Viewer. With the LUT button switched off we see the linearized version of the color.
Summary
Summary
All non-linear inputs must be linearized with either a Gamut node or through the Import tab of the Loader
Input images different from renders as well as Background nodes need to be converted to the bit depth of the renders for correct calculations - usually 16 bit floating point
A Gamut view transform is needed for previewing the composition
A Gamut node needs to be put before the Saver in order for sRGB Gamma to be baked into the final image
Page updated
Report abuse