Okay, so, we are now ready to move on

to something, pretty, 
different and exciting

um, and what that is, is
looking at moving images

so we spent all this time saying, okay, 
I could have a blank PImage

and i could figure out some 
interesting algorithmic way

to set all the pixels of that image

or, I could have an image thats coming 
from a file, like frog.jpg

and i could load that image, and i'll 
have all the access to all the pixels

and i could draw it on the screen 
and i could manipulate it

and do all sorts of stuff
what if, however,

we could have a camera, 
this is my weird drawing of a camera

and what if i could pull in a live image
from a camera into my Processing sketch

What could I do with that? what if I had a
you know, a movie file?

could I pull in that movie and play back 
that movie in my Processing sketch?

speeding it up, slowing it down, 
going in reverse

how could I-, how does all this 
stuff work?

How do we make this happen? So, let's 
first just take the basic transition from

flat image file to camera and the way 
that we're going to do this

is with Processing's Capture object
So, the Capture object, is part of,

Processing's video package
Now, I just realized,

there's kinda a crucial component to this,
if you are using, and again, this part of

the video, sadly, is going to just 
become obsolete in a little while

but, if you are using the 3.0 alpha series
and, hopefully, there will be a beta soon

or a final version, this will be true for 
all the 3.0 version's of Processing

Let's come over here and look, uh, here, 
if i go to, Import Library

let me just zoom in here
Import Library >> Add Library

and i pull this up, you won't, by default,
have the video library, so I'm going to

search under Processing, and this is what 
you're looking for, you wanna find

in this contributions manager, 'Video' 
library by The Processing Foundation

so, in order to run any of these examples,
or, to work with live video

or recorded movies in Processing, you need
this particular video library

in all the previous versions of Processing
prior to 3.0, this library came with

Processing, but its quite a large... large
library, also it's maintained and updated

on a separate schedule, so by pulling it 
in separately, all you need to do is,

Hey! Whoa! I haven't actually- Amazing!
I forgot that i just did a fresh install

of Processing here, so, this is-, 
we're going to test this out

you just wanna hit this 'install' button 
and, uh, while it's downloading

and should be ready to go, and now,
we're going to have this library!

yeah! and then it'll say 'remove', so, if
you don't have the video library,

make sure you get it (button click)
okay, back over here!

Once you have the video library, you 
now have access to the Capture object

you also have access to the Movie object

so, Capture being live video from some
camera, that's connected to your computer

Movie object, you'll use for video files,
that you're loading and playing

back in Processing, so

here's the thing, the thing that's 
the most wonderful about this

is that, both of these things are PImage's
essentially, all the functionality; image,

pixels, width, height, copy
any piece of functionality, you learned,

and practiced, and did with PImage, you 
could do exactly the same functionality

with Capture and Movie

the only thing that's different, is when
you load a PImage, like frog.jpg,

those pixels are never gonna change, 
unless you change them, right?

that file, that image is a 
flat, static image

those pixels are the pixels

you could do all the same operations! but
with a Capture object or a Movie object,

those pixels might be changing according 
to some schedule, of course,

we have total control over that schedule, 
we could say, give me fresh pixels from

the camera, or stop giving me fresh 
pixelsfrom the camera, or,

advance the next frame of the movie, or,
don't advance the next frame of the movie,

so this is an added piece of the puzzle, 
that we'll be able to work with

as we start using these classes, so, let's
sort of, uh, let's look and see how this

would work, there's a couple little
nuances here, so, i'm back over here,

and i'm in a sketch, so, this is just a, 
kind of a simple processing sketch

that I think we did at some point in an 
earlier video, I'm loading an image,

I'm drawing it on the screen, 
I'm using a couple things;

#1 - you can see I can dynamically resize
the image as i draw it, using the mouse,

or I could also tint it, meaning, 
change its color, so,

what I want to emphasize in this-, 
just first part of this video,

is let's make this the Capture object from
the camera, I have a laptop in front of me

its not all magic, let's get that image
from that camera, and let's see that there

and do all the same stuff for it, 
so, instead-, the first step is,

instead of a PImage, I wanna say, 
Capture and I'm gonna say video

now notice, as soon as I do that, I get 
an error message, it says, um,

if I look at the errors, you can see, 
the class Capture does not exist,

now this needs a little bit of work here,
but it's actually giving me a suggestion

which is nice, this is-, Capture and Movie
are both part of that Processing video

library that we just installed, so even 
though I've installed the library

I have to-, in my code, make an explicit 
reference that i'm going to use it, so,

I'm just gonna-, Processing will 
add this for you automatically,

in a bunch of different ways, 
but I'm just gonna do it manually,

so I just need to have an import statement
at the top; import processing.video.*;

now I have my Capture object, now,

you might think, you would say 
something like: "I said loadImage(),

so, loadCapture (should work) or 
something? createCapture, connectVideo,

startVideo", um, the way that 
this works however, is,

there is no function like that, we need to
use the tools and syntax of

object oriented programming, 
so lets come back over here

and if I have a video object, the syntax 
is to say, I wanna make a new...

Capture object, and I need to figure out,
what goes in there, so,

what might be some parameters 
that you need

when you're about to connect to 
the live camera?

maybe you might say: 
"Ah! camera over there!

I would like a very high resolution image"
or "a very low resolution image"

so, some parameters we're going to 
put in there as the width and the height

of our requested, uh-, images 
that we'll get from the camera

another piece of information that we 
might put over here, is... frame rate

do i want to get images from the camera 
at, 30 frames? 60 frames? 120 frames?

15 frames?

now, with both of these-, frames per 
second, so, with both of these,

certain cameras are only 
going to support

certain resolutions and 
certain frame rates,

so, a lot of this really depends 
on what you've got,

and I'm going to show 
you a way to figure out

what your camera makes available to you

but generally speaking, 640x480, 30 FPS,
those are, kinda good numbers to use,

and in fact, this (meaning >> FPS) 
is an optional parameter

you're just gonna get the default frame 
rate, if you don't request a specific one,

which is usually 30 frames per second

now, there's another argument 
that needs to go in here

and this is one of those tricky one 
that appears, when you're using-,

a lot of times when you're using a 
Processing library

One of the things we need to do, is, we
need to say: "A Capture object camera",

"you're (referring to camera) going 
to have new images available"

"you're looking at the room, 
you're looking at me,"

"you know where I want you 
to give those images?"

"I want you to give those images to me"

who's 'me'? 
this particular Processing sketch,

'this' sketch,

so the keyword 'this' needs to go in here,

now we could have a much longer discussion
about what the keyword 'this' means

and Java, and then we can sit here and
complain for a while

about how confusing these, like, archaic
concepts, and like, old-fashioned

languages like Java are

but for-, we don't really need to 
worry about it too much

to make all this stuff work, we just need 
to remember the keyword 'this' goes there

and I think it's kinda useful, to kind of 
think about the fact that 'this'

is referring to this Processing sketch

I don't want the camera images to go to
some other program on the computer

I want them to go to this Processing 
sketch, and we're telling the library that

this-, this happens in a lot of other ways
behind the scenes in Processing,

but you don't always have 
to use that keyword 'this'