The last thing we need to do here is apply the filter to the larger image before we

can save it.

The approach here is straightforward, but we have to make some tradeoffs.

This is something we keep coming back to but our image is pretty big.

Even at this stage, when we know which filter we want to apply, and

have a few seconds to carry out that operation.

In the time that we transition away from this screen,

to the time we hit Save at the end, it's not enough to apply the filter.

We can and will schedule the operation on a background thread but

at the current size that's still takes too long.

We don't need to update the UI right now.

So this filter operation can occur on a background thread and not block us, but

we do need it by the time the user hit Save.

So in the worst case, the user could just approach this screen, or

come to this screen where they add the tags and caption, and

hit Save immediately without bothering to add any of those.

So, we basically need to make sure this happens almost instantly.

The trade-off I'm going to make here is the same one we made earlier and

that is to use a smaller image.

Any other implementation would be far too complex and time consuming for

this course.

We've already spent quite a bit of time on this already.

Now, I'm not going to use the display photo because that's too small.

By too small, I mean with the way that the rest of our app is setup, we won't be able

to zoom in and out of these photos, and we still want to allow the user to do that.

We don't want to break an existing feature, just to add a new one.

Since we need to apply as soon as possible,

let's schedule an operation to handle it at the same time as we transition to

the photo metadata controller.

This way, we can be sure that we won't fire off any unnecessary operations

every time a user taps to check out a different filter.

Now, if we started immediately after transitioning to the current scene,

by the time the user is done entering a caption and

a series of tags, we should be able to process the filter in the background.

Let's define a function to handle this.

We laid the groundwork a few videos ago by defining an operation,

so we'll use the same approach here.

Func applyFilter.

Except this time we're going to accept a scaleFactor of type CGfloat.

Since we're going to use a smaller version of the image, we'll apply a scaleFactor.

Now the reason I'm making this a parameter is so

that it's easy to change and experiment with.

Okay, first we need to make sure we have a valid photo and filter to use.

So guard let image = photo, let selectedFilter

= filter else { return }.

Once we have an image, we need to resize it according to our scale factor.

Let's extract the width and the height of the image and assign it to two constants.

So imageWidth = image.size.width,

let imageHeight = image.size.height.

Then, we define a size by scaling these widths and heights.

So let size = CG size, and

the width is imageWidth times scale.

And the height is imageHeight times scale.

Now from there, we can use that custom method we defined earlier.

So we'll say guard let resizedImage =

image.resize to size, else return.

After that, you know the drill.

So using this image, we'll create an instance of filtration image.

So let filtrationImage= filtrationImage and

it takes an image so I'll paste in the resized one.

And then, we'll start an operation with this.

Let operation = ImageFiltrationOperation,

filtrationImage and selected filter.

Now for the completion block of this operation, we'll just assign the image

back to the store property, since we don't need to display just yet.

Completion block, if operation is cancelled,

then do nothing, when it is done self.photo =

operation.filtrationImage.image, okay.

The rest of this is busy work really since you know all of this.

Let's go back up to the top and define an operation queue so we can schedule this.

Let queue = OperatinQueue.

And the final bit is now to add the operation to this queue down here.

So, after the completion block we'll say queue.addOperation(operation).

We'll call this method applyFilter with a scaleFactor right in viewDidLoad.

So immediately after view loads, we'll go ahead and schedule it.

applyFilter, with a scaleFactor, right here, I played around for a bit.

And I think .25 is a decent scale factor that makes the image small enough for

the operation to complete quickly, and allow for some degree of zoom so

that we don't break our existing feature.

The bonus here though, with the way we've structured our logic,

is that if a user doesn't select any filter,

then this guard check will fail and we won't have to do any work.

In that case, we are going to have this really large image though.

Okay, let's wrap this section up by adding a save button, and a method so

that after entering all this information, a user can save a photo to disk.

Now after the applyFilter method, let's define another one.

So func setupNavigation.

So we need a saveButton in here which is a UIBarButton item.

And we'll use the systemItem initializer here because that has a default save.

The target itself and the Selector here is #selector

PhotoMethadataController.savePhoto.

Okay, let's add a placeholder for that method for now.

So @objc Func savePhoto.

We can't define this body just yet,

because we need to make some changes to our core data entities.

But this should suffice.

So let's go ahead and add this bar button item to the navigation item.

So naviationItem.rightBarButtonItem = saveButton.

And then we'll go ahead and

call setup navigation in viedDidLoad() right up at the top.

So that we actually have that save button.

And that brings our implementation of the photo metadata controller to a close.

We now have the UI and logic for the selfie portion of our app put together.

But we're still no closer to being be able to save it.

Over the next few videos, let's switch tracks from image processing

to modifying our CoreData models to accommodate this new information.