All language subtitles for 3. Keying with the Keyer

In this clip we're going to take a look at keying with the keyer.

So what exactly is luma keying.

So let's take a look at our script.

So the keyer can do a number of different functions.

The first one that we're going to take a look at is the

luminance key so that can be found in the properties bin

underneath operation luminance key.

Luma keying or luminance keying works with the

brightness and darkness of an image.

It isolates a select range of these values and places them into a new alpha.

It's really important to note that the keyer has

limitations and it may yield poor edge details.

Now the keyer default setting is to pull that luminance key; however,

it can do some of the following as well.

So let's go back up to the operation.

We can go to the top.

So it says red, green,

and blue keyer and that allows us to pull keys from the separate channels.

We can also pull different keys from red screens,

green screens, and blue screens.

It can pull the saturation and the max and min values.

So let's go back into this keyer and see exactly how it works for luma keying.

So by default the luminance keying or the keyer works with a trapezoidal

curve in order to select and isolate those values.

It allows a user to select black and white values and also gray values,

which will fall in between.

So here I have my lovely circle and I'm going to show a reference so this

is going to be my reference area that I'm trying to key.

The values are somewhere between 0.

65, 0.

66, and 0.

36, 0.

34, give or take.

I'm going to make sure that the values within this box are going

to be 0 in the alpha and all those outside the box are going to

fall to gray and eventually to black.

So let's take a look at the various different sliders in this tool.

Now the default sliders are going to be A and B and B is hidden over

here in the side and it also reveals a C and D,

which we will take a look at in a moment.

So the default value of A is 0 and the default value of B is 1.

When we change the slider for A,

so let's just take a look at this one here and we're going to go

into our alpha so here it basically crunches the image so it's

going to introduce more black into our edges and we're going to

erase some of that detail.

Now if I drop the value of B, look what it does.

It is crunching the white value.

So we're getting rid of all the detail again,

but in the opposite way where it's adding more white to the image instead.

So now let's go into the other two sliders.

So here's an example that we've already done and it's actually

really cool how I can isolate these values.

So let's take a look at the one before so we can see how exactly we did that.

So we had mentioned that the values that were in our

reference were between approximately 0.

65 and 0.

34.

So if I enter these values here, so I'm going to say 0.

34 and 0.

65 and I take a look at this tool now, so let's take a look at that there,

it's exactly what we saw in our reference.

So it's actually pushed the values that were between that box to

1 and it has gray values which fall to black and gray values that

fall to black on the other side.

Now we can change these values so if I pull in my A, look what happens outside.

So if it's equivalent to B, it's going to make it 100% white and if I take D,

it's going to make it and crunch so it's totally black.

So this really allows me to pull a key,

not only just based on the lights and the darks,

but it can also isolate the values of gray that fall in between.

So now that we have a basic understanding of the keyer tool,

let's take a look at how luminance works and the math behind it.

So here I have an RGB image, let's go to full color, and it's quite contrasty.

So if I go through the different channels, I have red, green, and blue.

It has quite high contrast and the way that luminance works is that I am

trying to desaturate all of the channels individually.

So I can actually take a saturation tool,

desaturate it so let's go back up to 100% saturation.

Here we go and desaturate it and this becomes the luminance of the image.

So how does the math work with that?

Well here I have the four different channels split out so I take a look

at my property bin and you're going to notice that the red channel is

shuffled into all the channels or at least RGB,

my green into RGB and the blue into RGB.

So I've isolated them separately.

Now the green channel generally has the highest luminosity and we have

basically figured out that the average luminosity is around 72%,

the red luminosity is around 21%, and the blue luminosity is around 7%.

Now if I multiply them out by those numbers and then

plus them back over top of each other,

they should round trip and basically equal that to the desaturated image.

So let's take a look.

So this is the math that has been broken out.

Here is the desaturated image and just to do a QC check,

so a quality check,

we're going to do a difference operation and if they are equal,

then it should show up black.

So let's take a look and they are equal.

So that means that this math here equals the

desaturation or the luminance over here.

Now there is a third method inside of NUKE that we can

isolate the luminance of an image and that is with the

luminance keying inside the keyer.

Now by default it will take the RGB image and it will

desaturate it and place it into the alpha,

which we see here.

So again, let's just take that and compare it.

So here I have shuffled my alpha into all of those layers and I have shuffled

this result into all of the layers and QC and it is the same.

So this just shows that again that the math that we've done here is correct.

That is how luminance is created.

Here's a really simple way to do it and the luminance keying allows us to

isolate this image and really modify the alpha for our needs.

So now that we have a brief overview of luminance keying,

let's take a look at how we would do that with an HDRI image.

So here I have an HDRI image and we have values just

slightly over 1 up here in the bright light.

So here we see 1.

1 across the board.

Now by default the keyer, so let's just go up to our properties bin,

will key between 0 and 1; however, our image has values that are well above 1.

So that might mean that we might miss some information that might

really help with creating a more refined alpha channel.

So if I go into my luminance keying over here and I hit the minus button,

it will expand that top range up to 4.

Now my image only goes to 1.

1 so that definitely falls between this range of 1 and 4

and it should give us a better alpha.

So let's take a look at the two different ways of keying.

So the first example that we have done has isolated the values between 0 and 1.

We can see here because the top value is 1.

Let's take a look at that alpha.

So here is that alpha.

It's not bad; it still needs some refinement here,

but I'm going to primarily focus on these values around the edges.

Now let's pull a keyer where we are working with these values that are above 1.

WE can see that there are still values above 1 here and let's take

a look at the results and so before and after.

Now it's pretty subtle just because our Super Whites or

values above 1 are definitely very small,

only 10% brighter,

but you can see that this second one that we've done

has a lot better detail in our edges.

So a softer falloff overall.

So it's definitely going to make a difference.

Small differences make big changes in the end when they are added up.

So now that we have a rough key, it will have to be refined.

These values up here are too bright, but we have a good start.

There's our premultiplied image.

We're going to take a garbage matte and apply this and premultiply our image.

So there is our isolated light and again it's working a lot better with

the luma keying setup that has those expanded values.

So in this particular clip we looked at the luma keying.

So how does the keyer work in general?

How can we isolate different values including the gray values?

We also took a look at how the math works with luminosity

and we also looked at the best way to work with keying or

luminance keying with HDRI images.