Original subtitles

In this clip we're going to take a look at keying in different color spaces.

So let's take a look at our script.

So the first thing that we're going to look at is the

linear color space versus log color space.

So the linear color space is a physical color space.

Images will often appear to be contrasty.

They will also appear to be too dark without color

space management or viewer LUTs.

So let's take a look.

So up here we have our LUTs.

It is by default in sRGB.

I'm going to turn it off and now it's at none.

So a LUT is a lookup table.

It's for viewing purposes only.

You can see it's quite hard to see the character here.

She's quite dark.

We can't see those details so we're going to turn back on the LUT.

So for more information on LUTs or other terminology that

you may hear in this particular clip,

please refer back to the NUKE Green Screen Keying

Fundamentals course as found at Pluralsight.

As a general rule of thumb, compositing is completed in linear color space.

This is often found in EXR images, but can also be found in other file formats.

Linear color space allows us to store more information in higher bit depths.

They can display values above 1.

So let's go into log images now.

So log color space, let's take a look at that there.

So let's turn off that LUT.

It's really washed out so images appear to be too washed out generally overall,

no matter if there is a viewer LUT or a baked-in color correction.

They represent film color scans.

Traditionally these file types were stored in Cineon flies or.

cin, which have since been replaced by.

dpx file types.

So there's a really great quote and description about log space.

I'm going to use the following description.

Log images are designed to carry as much information as possible about color.

Don't see them directly as useable images, but more as archives like zip files.

Once converted to linear, so the equivalent of unzipping an image or a file,

you can work with these images.

Now most compositing softwares like NUKE will force all

images into linear color space unless the user specifically

tells NUKE to do so otherwise.

So let's take a look.

So here we have told NUKE to change it.

We have going into this Log2Lin1 tool linear.

So linear we're changing it to log.

We're leaving the default different values in here.

So it was originally linear color space and now it is log.

So now let's take a look at a couple of different color spaces.

So we've looked at log versus lin.

Now we're going to look at sRGB and rec709 and see how they are

different from the first two that we took a look at.

So here is our sRGB color space image.

So what exactly does this mean?

Well sRGB color space is the default color space used on the internet.

It be used as a viewer LUT or be baked into an image so

here we have baked it into the image.

Here is the color space.

We are inputting linear and outputting sRGB.

It can also be used as a LUT so up here we have our LUT.

There is sRGB, but watch what happens.

So we have applied this color space twice, which we definitely don't want to do.

So either just use the image with an sRGB LUT or turn off

the LUT and bake it into the image.

Now be careful with baking these color corrections into the

image because once you have baked it in,

we do have some information that is lost.

Now the sRGB color space is equivalent approximately to

a linear color space image with a 2.

2 gamma correction applied.

So let's take a look at that.

So here's the sRGB color space.

I'm going to zoom in just a little bit so we can see the

details and here is a linear image with a 2.

2 gamma correction applied.

So is it before.

Take a look at her face and after.

So we can see that it's not 100% equal, but it's just approximate.

So now let's take a look at that rec709.

So rec709, you can see that changed ever so slightly from the sRGB.

Again it can be either baked into the image so here is our color space,

baking it into the image or be changed in the LUT.

Again, make sure not to do a double conversion.

The default color space for rec709 is used for HDTV.

So for high-definition images.

It can be used as that viewer LUT or be baked into the image.

It's equivalent or appears to be equivalent to a linear color space with a 1.

95 gamma correction applied.

So again let's take a look at that.

So here is the gamma correction and the rec709.

So again, very similar.

It's a little different than the last conversion that

we did so it is only approximate.

So now let's take a look at a couple of different color

spaces that we can use for keying purposes.

So down here at the bottom of our script we're going to take a look at the

default linear color space and we're going to pull a key,

just the default key.

These are all default keylight tools, which we will be using.

So let's take a look at our original image.

We will turn back on the viewer LUT to the default sRGB and look at a

tool that they've added here which is the switch tool.

So it allows me to switch between all these different

color spaces that we will be testing.

So up here I'm going to change it to white and I'm going to make

sure that I can see my original image there.

So here's my linear color space image and it's not looking bad.

We expect a little bit of artifacting in the backing region

just because there are some wrinkles still on the screen

here so it has been preprocessed, but it's not perfect.

And again, usually any value that is below 0.

05 is okay.

So generally speaking,

this will work when it's placed over top of a new background.

It may or may not work.

You might have to double check it, but as a general rule of thumb,

that's a good safe number.

So again, let's take a look at these values here.

We some artifacting that's going on in here wispies.

Not 100% happy with that so we are going to try some other

color spaces to see if we get a better result.

Now RGB compositing should be done in linear color space,

however, when pooling a key or creating alpha,

it doesn't really matter.

So all we care about is that black and white alpha and make

sure that we get the best edge detail.

So we can use different color spaces to get the best alpha and then

we can do the despill on the RGB image after.

So next I'm going to switch to the log color space.

So look at the difference already in the edge work over here.

So this was the linear.

This is the log.

Now I have added a small color correction just to increase the contrast,

but the log color space is looking a lot better.

So again, those values are well below the 0.

05 so that's great.

So, so far log is actually doing a better job.

So let's go on to our next example.

So sRGB, it's alright.

It's similar to log, but we aren't getting any better in our wispies; in fact,

it's almost worse so we're not going to use the sRGB.

Rec709 is quite similar so if anything,

it's actually worse so we won't bake that color correction in to get the alpha.

Next we're looking at HSV and that's definitely not

usable so why would we take a look at it?

So let me turn off the sample so Ctrl + Shift + click and turn

off the white and let's evaluate the HSV image.

So we want to take a look at this because we're really looking

for a channel that has great contrast in it.

So let's go into the individual channels.

This stands for hue, saturation and value.

So let's go into the red and it's contrasty,

but look at all the detail we're missing on the character's head.

So that won't work.

Green, again not very contrasty to the degree that we'd like it.

And B, that definitely won't work.

So in this case HSV is not a great solution.

So back to full color, okay, A and let's take a look at the next option.

So the next option is YPbPr color space and that

stands for the analog video signal.

So that's where we would find that color space.

Again, let's go into RGB so this is R, G, and B.

So green looks not bad,

but we are missing the character's head so that's not usable.

So let's take a look at that last one.

So this is the YCbCr color space and that is the digital video signal.

So this is the color space that we use for digital video; however,

look at the artifacting.

So why do we have artifacting in YCbCr?

Well,

unfortunately the chrominance in the YCbCr has artifacting in it

or compression so we would have to move some of that compression

to perhaps get a better alpha,

but if we compare this back against our log color space,

it definitely doesn't hold up.

So that is the YCbCr and back top of that to the log color space.

So in this example it looks like the log color space

creates a really great start for our alpha.

We will have to fix the core as we can see here, but it's pretty minimal.

So in this particular clip we looked at log versus linear color space.

We looked at the sRGB versus rec709 for LUTs and baking that color

correction or that color space correction into the image and we also

looked at trying different color spaces.

So if the default linear color space is not yielding the best results,

please feel free to try different color spaces; you might be surprised and

find a really great workflow for your perfect alpha.