All language subtitles for 11. Outputting Masks into an Image Sequence for Later Use

In this lesson,

we're going to learn how to output our mask into an

image sequence for later use.

OK, so we're right here where we left off in our last lesson.

And I want to use this as an example of how to show you,

basically,

how to get this Roto Node that we've created out our project

as an alpha and then bring it back in to use in the same way

that you would use a Roto Node.

So you're going to know the difference between what's it look like if

I'm using an alpha channel with an image like this,

or what's it look like if I'm using the Roto Node.

And then we can use the Roto Node to achieve creating that alpha.

Now, why would you ever want to do this?

Sometimes, you might start out with an alpha channel in the first place.

And you didn't have a Rotoscope So it would be useful in that

case just to know how to hook these up.

But why would you ever have a Roto Node,

and then output an alpha, and then bring it back in?

Well sometimes, whenever you're working on a project that is like a feature film,

a lot of times, Roto Nodes are really going to slow down your playback over time.

If you have lots of points in your Rotoscope that you've created,

lots of key frames, it's just going to be that much more information,

that much more data that NUKE has to calculate.

So pre-rendering off the Rotoscope is a great way to speed up your workflow.

However, if it's not slowing you down, you probably don't want to pre-render,

because it is possible to lose a little bit of data.

And it's also just a extra step that you have to go through that really isn't

necessary if you're not experiencing any playback issues.

Also, sometimes you might be creating a Rotoscope for somebody else.

And they may prefer to receive it as an alpha channel instead

of just getting the Roto Node and bringing it from your NUKE

script into their NUKE script.

But you definitely want to ask first.

If someone requests a Rotoscope from you, find out what format they prefer.

So now that we know how to create this Roto from our last lesson,

let's find out how to create an alpha from this.

So the first thing we need to do is bring in a Write Node.

So I'm just going to have everything deselected.

And we'll go ahead and grab that Write Node.

So just come up here to your Image button and choose Write.

Now, I didn't have anything selected because sometimes,

if you just drop in a Write Node with Node selected up here,

it can move your pipes around a little bit.

So that's not what I want to do,

because I have a very specific place that I want to plug

this Write Node into my Node Tree.

And that's going to be right here at my Roto Node.

So you may wonder why not plug it in at the last node in our tree,

which is what we're viewing right now, that Merge Node.

And that's because I don't want any of this data yet.

I want just the raw Rotoscope and not really wanting to

deal with the background that we added in.

So let's not even view this.

Let's just view what we have coming through that Write Node.

So basically,

now this looks the same as what it was when we were creating our Rotoscope.

I can double-click on the Roto Node.

And it looks the same as when we were drawing and animating that out.

So I can close this back out.

And now,

basically what we need to do is to tell the Write Node what we want it to make.

So if I just told it to write from this point here,

we would get this whole image, just this RGBA image,

of our actress waving.

And we wouldn't have the alpha because there was no

alpha channel in the original.

And you can tell that by looking at these little thumbnails here at the bottom.

So an alpha channel, or an image that has an alpha channel,

is going to have another box here on the end that will be white.

And you can see what that would look like here in the Merge Node.

So we need to basically tell the Write Node only to

look at one of these channels.

And it's going to be using the Roto as an alpha for that.

So to do that, all we have to do is come up here to our Write Node.

Go to Channels.

And choose Alpha.

And you may wonder now why is it red,

because we expect alphas to look just like a black and white image.

And the reason is because NUKE looks at that information and just

drops it into the first channel that it sees.

And it doesn't see the alpha channel first, which would be white.

It sees the red channel first.

So that's why we're seeing it in red right here,

and also because we're viewing this as RGBA.

If I look at my green channel, which is second after the red channel,

there's nothing here.

It's just a black channel.

And the same goes for blue.

If I look at the alpha channel, we're not going to see anything,

because it's actually not in the alpha channel yet.

It's basically the alpha information being stored in the red channel.

If we look at this red channel, it's going to be white,

because always, your RGBA channels are black and white images.

And then the computer looks at that image.

And it basically looks at it to figure out how to blend the RGBA

channels together to give you a color image.

So whenever we look at RGBA,

we have red because all of our other channels are basically blank.

So now that we have that all figured out, let's go ahead and write this out.

So we need to come over here to our file and click this

little button right here to tell it where we want it to

write this image sequence to.

OK,

so I'm right here inside of your Project files in your Reference files folder.

And I want to create a new folder for this sequence

that we're going to write out.

And so you can do this right here.

You don't have to grab a different window.

You can do it right up here in the corner by just going

to this button to create a new folder.

And then it's going to ask you what you want to name it.

And we'll just call this waving_alpha.

And let's put a underscore in there just where that space would be.

Go ahead and say OK.

And then it's automatically going to take you inside of that folder.

So that's why all those disappeared.

And we can see that in our path here.

And so now, we just need to tell it what we want this to be called as a sequence.

So basically,

every single one of our frames is going to get written out as a different image.

And we have 89 images here.

So that is going to definitely need to be in a folder.

We wouldn't have just wanted to dump those all into

the root of that reference file.

So let's just call this, again, waving_alpha, because that's what this is.

And I'll put a underscore in there just to separate those two words.

Just a little more clean for your file path.

Sometimes, you might have a different naming convention depending on,

maybe, where you work, or where you go to school.

It's up to you how you're going to name that.

And then, we need to tell it that this is going to be a sequence.

We're going to have multiple files written out here.

And NUKE needs to be able to recognize that each file is in a sequence.

And it's going to name those according to where it falls in this sequence.

So if it's frame five, we'll have a five here.

Now, before I just have a number butted right up against this word,

I like to put another underscore.

And then,

we use a special character to tell it that we want it to

fill in this number as it renders for us.

And I really just like to use the number key.

So I'll just hold Shift and hit the 3 on the top on my keyboard.

And that'll put in one of those little pound signs,

or number keys, hash tag, whatever you want to call it.

And then, you need to think about how many of these you want.

So this is only going to allow for it to fill in up to one digit.

But we have 89 frames.

So that's getting into the double digits.

So you'll want at least two.

But I always like to have a leading zero.

So my last frame would be 089.

So I like to put in two more so I have a total of three.

So anytime I have two digits,

I'll put in three special characters that it will fill in.

Now we need to decide what kind of file extension we want.

So there's lots of different choices.

I personally prefer a png sequence for something like this.

You could do an EXR if you wanted a totally lossless format.

But for something like this,

the only thing that I would avoid would be a JPEG sequence

simply because those are not lossless.

They are very lossy.

And you might end up with a little aliasing around those edges.

So we'll just do a png sequence for now.

And so you just want to put a period and then type in png.

And then we're ready to render.

So go ahead and hit Save.

And you can come down here to Render and hit that button.

And this is also a little interesting how this does this.

So whenever the sequence was originally imported, it was named 0-89.

But NUKE likes to start at 1.

So you can write it out from 1 to 90.

It's still the same amount of frames.

It's just not starting at zero.

Or you could change this to a zero and write to 89.

Either way, you're going to get pretty much the same result.

So I'm just going to leave this as it is.

Go ahead and hit OK.

And you can see that renders really, really quickly.

So now, I want to bring back in that sequence that we just created.

OK, so I've just got it here in your Reference files.

So let's go ahead.

And that's going to be the waving_alpha.

So we'll just grab that folder and drop it onto our Node Tree.

And you can see it moved those around just based on what I had selected.

I'm going to put that back into place.

And we'll just have this over here to the side for a second.

And usually, you don't want to disconnect anything from your tree.

So basically, what I want to do is just disconnect as little as possible.

So I know that I'm going to be using the A pipe with this later on.

So I'm going to disconnect that one for now.

And then we can put the Write Node over here to the right.

And then we'll put the Roto directly out to the side of the Read Node.

Then, I'm going to put this Read Node right underneath that Write Node.

So this is a good way to be able,

if you're going to leave the Roto and the Write here on your Node graph,

to just be able to see visually this Roto and this

Write Node output this new Read Node, which is our alpha that we've created.

So now what I want to do is copy this alpha channel

into the alpha for this Read Node.

Now,

that might be a little bit confusing if you haven't gotten into channels yet.

So I'll explain it to you.

Basically,

we want to have another little white bar here at the end by the

time we have united these two images together.

So right now, even though this is only a red channel,

it has the look of an alpha, because it's just this silhouette.

So we can use a Copy Node to take this red data and tell it to

become the alpha channel for this image.

So let's go ahead and add in a Copy Node.

I'm just going to go ahead and deselect because I don't want it

to automatically hook up any pipes for me.

And the Copy Node is located right up here in your channel.

So just click and hold that.

And come down here to Copy.

And we'll just drop that right in there.

I'm going to put this directly across from the Merge,

because that's what it's going to hook up to a little bit later on.

And then, let's go ahead and tell our viewer to look at the Copy Node.

Now, right now, we get an error because we haven't changed anything yet.

But let's talk about how we know which one of these

pipes needs to be hooked up where.

So basically, we're wanting to look at our original image as a the background,

I would say.

So it's similar to the way you're setting up whenever you're doing a Read Node.

So I'm wanting to copy the channel from my alpha into this Read Node here.

So this needs to be my background.

So I'll grab the B pipe and drop that onto the Read Node.

And then we'll take this A pipe and drop it onto the alpha we created.

Now, we still have that error.

And that's because we haven't changed anything inside of the Copy Node.

So right now, it's still trying to copy that default setting of alpha to alpha,

which we don't have an alpha in this file here.

So doesn't really make any sense.

So I'm going to tell it to copy the red and tell that to go into the alpha here.

So to change that, we'll just go to this first option and choose RGBA Red.

So now, as we're viewing this, a little bit of a change happened.

And you can see it now.

As these two images come together, this red has become the alpha.

And then we still have the RGBA information from our

original background Read Node.

And it's been copied here.

So this is a easy way to view this, how it says red goes into alpha.

And it just shows you that right there on the Copy Node.

And then you can also see what's happening based on these little thumbs.

I really like those little thumbs.

It's a really visual way to be able to understand what's happening.

And now,

all we have to do is grab our A pipe from our Merge

Node and drop it onto the Copy Node.

And really, right now, it looks exactly the same.

And that's because we're still viewing the Copy Node.

So let's just take the Viewer and drop it onto the Merge.

And I'll go ahead and hit Play.

And you can see that it's very similar outcome to what we had with a Roto,

pretty much indistinguishable.

If I zoom in here, we're not really getting any aliasing along the edges.

So that was definitely a high enough quality file type

just using that png in this scenario.

So hopefully, you understand a little bit more about channels now.

And you also know how to write out your own alpha channel and

then how to use it in your own project.

So thanks for sticking around and watching this Rotoscoping course.

And good luck in creating some of these techniques in your own projects.