COLOR CORRECTION USING ARITHMETIC

UPDATE
“Under the Hood”
(Or “How I Got There For the Mathematically Inclined”)

Figuring out the percentage of grey for each color channels is easy – divide each channel by the maximum value and you’ll see the percentage of grey that each channel contains. In this case: R=65.1%, G=59.6%, and B=60.8%. Unfortunately, that information is useful only for identifying whether or not the pixel chosen is close to neutral. In this case, it is. The challenge then becomes how to use that information to make a global change to all pixels, so that the color casting channel is reduced in “primacy.” The easiest way to do that is by using the Levels or Levels (Individual Controls) effect. Since I prefer to use Levels (Individual Controls) for its ease of access to individual controls, I chose that effect.

I wanted to preserve the overall level of luminosity in the footage, rather than darken it, so I chose to work from the input white channels of the effect, rather than darken the image by working from the input black. Knowing that the brightest channel in a mid-grey area would reveal the color cast, I had to find a way to preserve the full color value of the brightest color, while bring the other pixels up in value. The input white value of each channel represents the maximum brightness of the brightest pixel in a color channel. Assuming that there is even one pixel in an image that is at full brightness, then all of the other pixels are appropriately placed in value. On the other hand, if there are no pixels in a color channel at full brightness, then the image will have a color cast – the lower in value the brightest pixel happens to be, the greater the color cast. By adjusting the input white value in the Levels (Individual Controls),  you can shift the brightness of a particular color channel so that the brightest pixel in an image will be changed to 255. For those who love expressions, it’s like using the linear() method on a color channel.

The answer to finding that value lay in reversing my initial process – instead of finding out the percentage of grey that each color channel represented, I needed instead to produce a number that would represent the inverse of the percentage – 1.536 (rounded up to 1.54) – allowing me to decrease the threshold for the input white for the other two channels. Multiplying them by this number would result in the appropriate amount of channel-specific white input decrease, yielding a color corrected image. Of course, this rests upon my initial choice of neutral pixel. If I chose the wrong one, then my efforts were useless. After that, finding the right gamma balance was a matter of personal taste . Did I want the image to have greater contrast? Then I should push the gamma toward the brighter pixels. Did I want it to have less? Then I should push it toward the darker pixels.

Technically, the process could work in reverse – dividing 255 by the darkest color value, and adjusting the input black levels of all the values – but some rather unpleasant, if technically correct, results are generated that way. Also, this process does have the net effect of brightening your image, so be careful of generating new hotspots, but by knowing the correct input white value, taken from the relationship between color channel values in a spot that SHOULD be neutral grey, it is possible to remove a color cast from virtually any image in a relatively short amount of time using simple arithmetic.

Color correction can be a pain – little wonder that colorists make the big bucks! But by doing a little arithmetic you can get rid of any color cast quickly and accurately.

There are 5 easy steps to follow…

1) Identify an area in your image that should be a neutral color – typically a shadow on a neutral color. This helps to determine the color cast of your footage.
2) Hover your cursor over the shadow and write down the color channel (RGB) information, which can be located in the Info Panel, located in the upper right corner of the Standard Workspace. Save this information for later.
3) Determine the color channel with the highest color value, and divide that into the maximum value for the color bit depth of the project. (255 for an 8bpc project). We’ll call the resulting value the Color Correction Factor
4) Multiply the remaining two color channel values by the Color Correction Factor
5) Enter the resulting numbers as the Color (Red, Green, or Blue) Input White values.

Voila! Your footage should now have an accurate color correction. The only adjustments necessary are for contrast by adjusting the RGB composite input black and white amounts, as well as adjusting the RGB composite gamma value. Let’s examine how this effect works using a piece of footage that I shot this spring…

While viewing a piece of footage that I shot of the yoshino cherry in my backyard (hence my company’s name), I noticed a very slight red cast.

So, I sampled the values from a small hotspot in the background, about a third of the way down on the left hand side. The sampled values that I got were R=166, B=152, G=155. Since the R value was the hottest of the three, I divided 166 into 255 and ended up with 1.54 as my Color Correction Factor. I multiplied the Green and Blue values by the Color Correction Factor and ended up with 234.1 and 238.7, respectively. I then applied Effects>Color Correction>Levels (Individual Controls) to my footage and entered those two values for the Input White for the Green and Blue channels…

While the red cast is pleasant on a cherry tree, the petals are practically white,  except for the fringing on the inside near the stamens, giving the trees a vibrant pink when viewed from far away. Since I wanted an accurate and consistent color in all of my footage from that day, I made the choice to stick with the color correction, rather than leave the red cast in the footage. That way I didn’t have to worry about applying a separate instance of SA Color Finesse 3 when I imported my video back into After Effects from Premiere Pro via the Adobe Dynamic Link.

The final step to get the footage looking just right was to add some contrast with the composite input white and black values and gamma adjustment. Since there was plenty of luminance on the upper end, I only raised the black input value and lowered the gamma amount a touch and came up with the following:

Admittedly, this method is not fool proof, but it can usually get you pretty close to a desirable color correction. The only exception that I’ve found thus far is a strong color cast, specifically yellow. Even a moderate blue, red, or green cast can be cancelled with passable results using this method. As with any footage, be careful of how strongly a method is applied, as noise and other artifacts can enter the process resulting in undesirable and unpredictable consequences.

Hopefully this method informs your work as you composite your footage together in new and creative ways!

I was given an interesting Twitter challenge this evening, and thought that I’d post the solution here on my blog. John Dickinson of MotionWorks asked how to get one layer moving precisely in opposition to another layer in 2D or 3D space around a given point, and without using null objects of any kind. Here are my solutions:

2D

a=thisComp.width/2;
b=thisComp.height/2;
refl=[a,b];
par=thisComp.layer(“Parent Layer”).transform.position;
dist=sub(refl,par);
add(refl,dist);

3D

a=thisComp.width/2;
b=thisComp.height/2;
c=0;
refl=[a,b,c];
par=thisComp.layer(“Parent Layer”).transform.position;
dist=sub(refl,par);
add(refl,dist);

***Place these expressions in the position value of the layer that you wish to mirror the “parent” layer.
***You can substitute any position values that you want in the “refl”, including another layer or null.
***Read on if you want to see how the math works!
***UPDATE: If you copy/paste this into After Effects, make sure that you delete any extra characters that come out of the code (like “?” between each line). Also, my copy of AE doesn’t like the quotation marks around “Parent Layer”, so you’ll want to replace them as well.

How the Math Works

The trick for me was seeing the relationship between a given point of reflection (in this case, the center of the composition in comp and world space) and the location of the “parent” layer. If I could find the distance between each of the parent layer’s dimensions and the reflection point, then I could add that distance to the reflection point and call that resulting value the position value of the child. In other words, as the distance increased between the parent and the reflection point, the distance would increase IN THE OPPOSITE DIRECTION for the child layer. This worked in both 2 and 3-dimensions.

Since position information for layers are arrays, I could  use the vector math expressions to make my work a little easier and clean up the code. (My initial solution that I sent was much longer and less elegant! Fortunately, I had a chance to clean up my work a little bit!) The add() and sub() methods both require two arguments, each arrays of either 2 or 3-dimensions, otherwise known as vectors. So, I took the reflection point first, established all of it’s values, and gave it a variable named “refl”. Next, I needed to have the position value of the parent layer entered into the expression, and since it needed to be variable AND manipulable by the vector math methods, we set it up in the variable “par”. Finally, the distance between the parent layer and the reflection point (stored in the expression using a variable named “dist”) was established using the sub() method, and added back to the reflection point using the add() method, yielding the final result.

Phew!!

What the add() and sub() Methods Do

Vector math methods take two vectors and perform mathematical operations upon their values in the order the user defines, and does so for each dimension of the arrays within the method. Put more simply, the add() method looks at the first dimension of each array and adds them all together, does so for the second dimension, and so on. It expresses it’s final answer as a new array. The sub() method works in the same way, but it subtracts the array dimensions. In other words, the add() method looks like this:

a=thisComp.layer(“Example”).transform.position[0];
b=thisComp.layer(“Example”).transform.position[1];
c=thisComp.layer(“Example”).transform.position[2];
d=thisComp.layer(“Example 2″).transform.position[0];
e=thisComp.layer(“Example 2″).transform.position[1];
f=thisComp.layer(“Example 2″).transform.position[2];
x=(a+d);
y=(b+e);
z=(c+f);
[x,y,z]

Now I don’t know about you, but I like this a LOT better…

vec1=thisComp.layer(“Example”).transform.position;
vec2=thisComp.layer(“Example 2″).transform.position;
add(vec1,vec2)

Instead of having to write a bunch of variables describing each dimension of each layer, we can just call up all of the values at once and let After Effects do the work! (Disclaimer: the draft that I sent to John was the first one above. With all of the variables. How embarassing…!) The sub() method works similarly to the add() method, except that it subtracts values rather than adds them. (Shocking, I know…)

Conclusion

Thanks, John, for a great challenge! It made me think a little bit at this late hour (1AM EST as I write this post), but also gave me a chance to demonstrate some great expression methods!