SG CCTools - For Color Management and Linear Workflows
From LightWiki
Contents |
Introduction
The Color Correction Tools by Sebastian Goetsch (SG_CCTools) is the first color management system that has been developed ever within any 3D commercial software. Sebastian Goetsch has solved brilliantly a system that not only implements color management facilities within Lightwave 3D, but also facilitates a lot the Classic Linear Workflow. These tools work nicely also with the Inverse Linear Workflow and Multipas Linear Workflow.
Note: I strongly recommend you get an Issue# 18 of HDRI3D magazine where I propose the 3 Linear Workflows mentioned before ( http://www.hdri3d.com/issues/h18.htm )
Installation
You can download latest version of the plugin from Sebastian's webpage
Unzip the files (32Bits version or 64Bits version) in its respective folder. Better if we create a special folder for these plugins - later we'll see why. Add the 3 plugins in Lightwave.
Modules
SG_CCTools is composed by 3 modules:
- SG_CCPicker
- SG_CCFilter
- SG_CCNode
SG_CCPicker
To replace the Default Picker, go to Options => Preferences => General tab and choose SG_CCPicker as your new Color Picker. Once you have made this, you'll never come back
The SG_CCPicker is currently the only customizable picker that automatically linearize any color we choose. It has 4 panels:
WinPicker/History Panel - Here we have two ways to pick a color. By using the classic Windows color picker, or by clicking in any place of our screen by using the Screen button. This works if your color source is an image in other window, or if it's even in another application; we can switch to other program, open any image and choose any color displayed in our screen. This panel stores also the last 30 colors we have used, so this could be an additional way to choose a color.
'Tint/Shade Panel' - You should already know this useful way to choose colors.
'Numerical Panel' - We can specify colors directly in XYZ color model. By multiplying values, we can go beyond the 8-bits limit. So yes, SG_CCPicker is floating point (FP) as well.
'Config Panel' - Here is where reside some of the most powerful features of this picker. There's possible to customize up to 8 images for our color screen. This means that we can use ANY color wheel or color table (Discreet color wheels, Color Finesse hue offset wheel, Kelvin temperature bar, wavelength bar, HSV>RGB table) or any other color scheme you want to design. We can even get a CMYK Pantone within Lightwave. We can get them all within SG_CCPicker. These color tables can be saved as images of 128x384 pixels.
The Config Panel also allow us to linearize or color encode any color we pick. This color conversions can be made by input any simple gamma curve or more complex gamma formulas for sRGB and Rec. 709.
Example Usages
CMYK color (RGB equivalent) linearized by SG_Picker
Blackbody Temperature / Kelvin
Bluish color, linearized for sRGB, AdobeRGB 1998 and rec. 709
Sebastian's Tip: Roll your mouse wheel (MW) to increase or decrease saturation. To increase or decrease the brightnes, press RMB + MW. We can see how numbers change in the Numerical tab. Pretty cool eh?
SG_CCNode
This node was made for cases in which we need to linearize dark 8-bits images. For avoiding quantitizations, it's beter to perform linearizations on FP space. So for those cases, we may use the blank image trick or solve the task in the nodal system with this tool. Good thing about SG_CCNode (besides it's pretty fast), is its gamma correction options for simple gamma exponents, sRGB and rec 709.
Example Usages
HD footage linearized with SG_CCNode
SG_CCFilter
For advanced conversions at gamut level, we have the SG_CCFilter. This filter can be used as pre-processing or post-processing depending on the color management workflow we are using.
Note: I strongly recommend you get an Issue# 18 of HDRI3D magazine where I propose a general Color Management Workflow with which the SG_CCTools fits perfectly.
The SG_CCFilter is capable to manage the most advanced color conversions and rendering intends: Perceptual, Absolute Colorimetric, Relative Colorimetric and Saturation.
It uses ICM/ICC color profiles to make this conversions. In order the SG_CCFilter can recognize our color profiles, we need to specify the route in a .txt file. Something like:
C:/ProgramFiles/CommonFiles/Adobe/Color/ProPhoto RGB.icm
...and so on.
This file should be in the same folder where you installed these plugins - that's why is advisable to create an special folder for the SG_CCTools.
For color profiles, we can use different files from different folders, but in an studio environment or collaborative projects, it's advisable to keep the same route, in the same order, with the same color profiles for all computer nodes, so that scenes can be portable from computer to computer. It's also advisable to create folders for both, linear and log versions of these color profiles.
Note: Be sure to separate linear versions from log versions in a different folder from Adobe's applications, so these applications don't confuse them if these color profiles share the same internal name.
Creating linear color profiles
Since we can perform color conversion with SG_CCFilter, it's possible also to use it for working accurately in linear light as well. That is to say, for linearizing images taking into account gamut conversions (chromaticities). In order to do this, we need the usual color profile (a gamma encoded version), and a linear version of the same color profile. Since most of the professional color profile makers are not so cheap to only use them for making linear versions of our color profiles and, since color profiles are in dependence of the particular images devices we are using in a given production (film stocks, digital video and photographic cameras, TV systems, scanners, monitors, papers..), I'll show you how to make a linear color profile in a very cheaper and easy way:
Go here: http://www.color.org/profileinspector.xalter and download ProfileInspector.
Once installed, open the application, go to Browser and load an ICM or ICC color profile. Let's say AdobeRGB 1998.icm profile. There, we can see the profile structure and some other useful info. What we care now is the signatures in the Tag Table (12 tags). Select the fourth, fifth or sixth tag (rTRC or gTRC, or bTRC) and double click in one of them. We can see the specific gamma curve for this color space in that specific channel (a simple curve exponent in this case). To set a linear gamma, export the curve tag. Name the txt file as aRGB_gamma.txt and save it in your linear profiles folder. Leave the ProfileInspector opened for a moment and open the txt file. We have now the right syntax to change this gamma. Change 2.200000 by 1.000000 and save it again. Come back to ProfileInspector, select rTRC signature and import the new curve you have just saved. Gamma curve should be linear now. Do the same thing with gTRC and bTRC and save this profile as Linear_AdobeRGB 1998 .icm. You have now a linear version of this working color space. We can do this for other color spaces like ProPhotoRGB (very advisable), sRGB, HDTV, or any other color space if you know its gamma formula. Just notice that internally, both profiles (the log version and the linear version) share the same name. Professional Profile makers allow to change this..
Example usages
Preprocessings
Wooden texture, converted from sRGB to AdobeRGB 1998 in pre-processing.
Same texture converted to Linear ProPhotoRGB.
Tip: Yes! with the new SG_CC Tools, we are able to work properly, for first time, with one of the wider gamuts available: ProPhoto RGB! This colour space is not only better for motion picture production due to its wider gamut but it also works with one of the most convenient gamma exponents (1.8)
Note: It's advisable to perform conversions to wider color spaces in at least 16-bits space.
PostProcessings
Scene was worked in linear ProPhotoRGB. Raw render, no managed colors:
Here, we've used SG_CCFilter as a LUT tool for previewing in log space according to my monitor color space (a CTR monitor in this case):
The setup is like this:
input profile: 'My Working Color Space.icm' - Input Intend: Relative Colorimetric - Output profile: 'my monitor profile.icc' (log version) - Output intend: (it doesn't care in this case - leave it as Perceptual)
Even more, we can preview how this result will look in other mediums as well (notice I'm referring to the ProPhotoRGB output, not to our screen output), like let's say HDTV - not only in gamma aspect but also in its chromaticies:
The setup is like this:
input profile: 'My Working Color Space.icm' - Input Intend: Relative Colorimetric - Output profile: videoHD.icc (log version) - Output intend: (it doesn't care in this case - leave it as Perceptual)
Now, we may notice these results are pretty similar to how Discreet's colorgrading systems manage colors, but slightly different from Photoshop or AE proof colors. Besides different color engines, this is mainly due to Adobe uses sRGB space as connection space (a similar concept to how I proposed to work - before SG_CCTools - with cineon footage and rec. 709 in a motion picture production), but in this case it seems this is due to Adobe tries to avoid device-dependent color spaces in the conversion equation to keep a more standard "look" (which I don't think is necessary with the new displaying technology).
But anyway, it could be a more secure way; so if you want to go with the Adobe's way, the setup is like this:
input profile: 'My Working Color Space.icm' - Input Intend: Relative Colorimetric - Output profile:'my_screen_profile.icc' (log version) - Output intend: Perceptual
Add other SG_CCFilter instance in the next slot:
input profile: sRGB.icm - Input Intend: Relative Colorimetric - Output profile: videoHD.icc (log version) - Output intend: (it doesn't care in this case - leave it as Perceptual)
Now the result match Adobe's applications. Then you get the picture for other type of conversions. Obviously this setup is not necessary if your working color space is HDTV (the first setup is enough in that case).
But wait, there's even more: we can get an approximation to how our output render will look like in a cinema theater within Lightwave 3D!
The setup might be like this:
Input profile: 'My working Color Space.icm' (Linear ProPhoto RGB is recommendable in this case) - Input Intend: Absolute Colorimetric - Output profile: Negative Film Printing Density.icc - Output intend: Absolute Colorimetric
In the next filter slot, add other SG_CCFilter with this settings:
input profile: "Film Theater Preview.icc" - Input Intend: Relative Colorimetric - Output profile: 'my_screen_profile' (log version) - Output intend: (doesn't care in this case - leave it as Perceptual)
In this example the Negative Film was Kodak 5218/7218 Printing Density, and Theater Preview was Kodak 2383:
In this one the Negative Film was FujiFilm ETERNA 500 Printing Density, and Theater Preview was Kodak 2393
This is the first time that someone can make this within a 3D package!
As we can see, SG_CCFilter is useful also to provide "film looks" to our final renders.
...playing a bit with film desities profiles and a curve filter ('toe and shoulder' kind adjustments made with HDRExposure/Exposer):
There are several ways to use the SG_CCTools according to your unique color workflow and pipeline. This tut only pretends to show some of the potencialities of SG_CCTools by explaining what are these tools and its basic usage.
If you want to know how to implement these tools within a general color management workflow in a coherent way, I strongly reccomend you get an Issue# 19 of HDRI3D magazine ( http://www.hdri3d.com/issues/h19.htm ) There, I propose 2 methods (the screen method and the perceptual method) to work with these tools, and I explain the only method that I found, so far, to take profit from wider gamuts by keeping color consistency.
I said 'so far' because I'm still discovering new possibilities, techniques and possible enhancements for this color management system. So I encourage you to discover and share new methods, techniques and possibilities. It would be really great to see something like this implemented as a built-in system in future versions of Lightwave3D.
Many thanks to Sebastian Goetsch, not only for coding so refined piece of software - freaking genious developer! - but also for his generosity to make this advanced color correction system free for educational and commercial use.
You can find the SG_CCTools here:
http://www2.informatik.hu-berlin.de/~goetsch/CCTools/
Gerardo Estrada 2008
