Original subtitles

In this clip we're going to take a look at keeping

the alpha values between a 0 and 1.

So let's take a look at our script.

So the first example that I'm going to take a look at is I really

like to keep the images alpha to 1 at all times.

Now it's not always mandatory,

but we'll take a look at why that could be important.

So here I have the read node and if I scroll down to the properties bin,

you can see the option for auto alpha.

So let's take a look at the alpha.

By default it is black and I can turn auto alpha to 100% white.

The second option is if I turn that off, I can add a shuffle node.

So the shuffle node by default will be the default alpha

value so let's take a look at the shuffle.

It will retain the black, but I can force white into the alpha as well.

So again 100% white alpha in this image.

So let's go back to full color, a,

and take a look at why we might want to want to

retain some alpha values in our image.

So the first example is this here so here is a premultiplied image,

no alpha, and a constant background that also has no alpha.

So when I merge the two of them together you can see we

don't get what we were expecting.

That is a bright green circle on top of the blue background.

Now the blue is retained just because there's no other information on top of it,

but the center circle portion here has changed because it doesn't know

what to do with the green circle because it has no alpha.

So into the alpha and there's no alpha overall so this won't work for us.

The second example is a green constant, again no alpha,

but an alpha in our blue background.

Again when we put a over b, because our circle has no alpha,

it doesn't know what to do,

but it carries through this old alpha from the blue background.

Next we have a green premultiplied image with an alpha over

top of a blue constant with no alpha.

Now it carries through the circle's alpha,

but because again there's no circle or any other image

over top of the blue background,

it's not changing it and we are retaining the green circle over top.

So this is a great alternative.

The last alternative will allow us to retain the best alpha overall.

So again a premultiplied green circle so just take a look at that with an

alpha and a constant background also with an alpha,

a over b, and it retains that circle still,

retains the blue background, and carries through a solid alpha.

So now that we know why we might want to keep an alpha for

images that are placed over top of each other,

let's take a look at a couple of other examples where

the alpha may not be either 0 or 1.

So let's take a look at that.

So the first example is two circles.

So here's one circle, solid alpha 1 and a second circle, solid alpha 1.

If I place one over top of each other,

the alpha across the board is 100% white so this is

exactly what we are looking for.

Now in our next example, certain operators will change our alpha.

So here we have the same thing, a circle,

solid alpha, second circle, solid alpha,

but we use a plus operator.

Now not only does it change the rgb, but it also changes the alpha.

So it changes the alpha to 2 and it's artificially inflating

the alpha to a value that we don't need.

So let's take a look at what that looks like over top of our background.

So here is a background over top of it and now our alpha

is solid everywhere else at 1 with the exception to where

those two circles overlap.

Now we can force the values in the alpha between 0 and 1 so

there aren't these extra code values and one of the ways to

do that is with a clamp tool.

So I've taken those two circles with the value of 2 in the alpha and clamped it.

So let's take a look at the clamp tool.

By default it clamps the alpha channel only and it

will keep the values between 0 and 1.

So let's take a look.

So here it changes the alpha to 1.

Notice how it doesn't change the rgb.

So on and off, only changing the alpha.

So now if I take a look at the two,

so here's the one with the alpha of 2 versus the alpha of 1

and do a qc check with a different operator,

it is the same.

So there are no huge differences with this particular example,

but it is introducing those extra code values.

So let's look at the other extreme where we are

looking at negative alpha values.

So here I've artificially pushed the alpha to a negative value

and I have merged over top of that same checkerboard

background so because there is no alpha,

it doesn't know what to do with the image on top of it and it looks transparent.

So it's not giving us that proper math.

If I go into the clamp tool, again clamp those values at 0 and 1.

So here is the negative value here.

In the alpha, clamp that value at 0 so rgb isn't changing, just the alpha.

Take a look at it.

Again it looks like it's transparent so if we compare the two images,

qc difference, with the difference operator,

they are the same.

So again,

generally speaking if you have alpha values that are below 0 and above 1,

for the most part you are just carrying around extra code values.

There is nothing more black than 100% black so 0 and there's

nothing more opaque than 100% opaque which is 1.

So alpha values should be between 0 and 1 and you're just

carrying around extra information for processing,

which is not needed in the alpha if they are not between those two values.

So now let's take a look at what happens if we have values above 1 in our rgb.

So here we have two images,

one of them is a jpeg and that is an 8-bit image and

the second one is a 16-bit exr.

Now you'll notice right there that took a little bit longer to load

the exr and that is because it is a larger image.

So the 8-bit image contains 256 levels of information.

The values represented are between 0 and 1 in NUKE.

So it will clip or clamp values that are over 1 and that includes rgb and a.

So I'll use the word clipping and clamping the same as

basically ridding of certain code values.

Now in the 16-bit image over here, 16-bit images contain 65,

536 levels of information so far more information.

They are represented in NUKE between the values of 0.

0 and 1.

0+.

Now I say 1+ just because a 16-bit image doesn't

necessarily contain those extra values, but it can contain values over 1.

Now values over 1 are called Super Whites and these are

RGB code values that are above 1.

They are typically found in 16-bit images or higher and

they are also found in linear images.

So we'll go more into linear versus log images in our next module

so be sure to watch that for more information.

So back to our images here.

When I compare the 8-bit versus the 16-bit,

generally speaking over here it's looking the same.

We can tell that this is indeed an 8-bit image because we can

scroll and take a look at the metadata,

so we scroll here in the property bin and it is 8-bit fixed

versus the 16-bit image which is 16-bit half flow.

So now let's do a very aggressive color correction.

So here I have a gray tool and I have brought down the game very, very far.

So here it is and we're going to focus again up here on the

sky where our Super Whites whites may be and the same color

correction for the 16-bit image.

We can see that there's more information that has popped up in the clouds.

So the reason that we want to retain these Super White or code

values above 1 if there are any in an RGB image is because we can

push the color correction further and we can really retain all that

information that is in the image.

If we clip or clamp them, then we lose that important information.

So for the most part,

it's a really good rule of thumb to never clip or clamp values over 1 in

the RGB channels but rather only keep that to the alpha.

So let's take a look at a couple of ways to do that with our tools.

So here is a green constant and the green constant has

artificially been inflated to an alpha value of 2.

The clamp will take care of that so it will clamp it to 1,

but the gray tool can also do the same.

Now keep in mind the gray tool is generally reserved

for color correction purposes.

It has other options inside of it so when you see a gray tool,

it will generally be recognized for color correction versus a clamp that's very

specific to just keeping code values within a certain range.

So this is the preferred tool to use when clipping or clamping your values.

Inside of the gray tool if I scroll to the bottom of the

property bin you'll see that there is a black clamp and this is

by default so we'll make sure that there is no negative black

values and also white clamp.

So you can clamp that white value and by default it's turned

off because you don't generally want it.

The channels for a gray tool generally come in RGB so you do have to

force it to alpha so that you are not color correcting your RGB and

restraining or keeping the values between 0 and 1.

So only keep those values between 0 and 1 in your alpha.

So as a quick recap of this particular clip,

we took a look at the importance of keeping our alpha values

between 0 and 1 and why we want to make sure that we don't clip

or clamp those values in our RGB.

We also looked at the clamp tool versus clamping or

clipping those values in the gray tool.