Processing an Image Using Built-in Filters

You can add effects to images by applying Core Image filters to CIImage objects. Figure 1 shows three filters chained together to achieve a cumulative effect:

1. Apply the sepia filter to tint an image with a reddish-brown hue.

2. Add the bloom filter to accentuate highlights.

3. Use the Lanczos scale filter to scale an image down.

CIImage processing occurs in a CIContext object. Creating a CIContext is expensive, so create one during your initial setup and reuse it throughout your app.

let context = CIContext()

The next step is to load an image to process. This example loads an image from the project bundle.

let imageURL = URL(fileURLWithPath: "\(Bundle.main.bundlePath)/YourImageName.png")
let originalCIImage = CIImage(contentsOf: imageURL)!self.imageView.image = UIImage(ciImage:originalCIImage)

The CIImage object is not itself a displayable image, but rather image data. To display it, you must convert it to another type, such as UIImage.

A CIFilter represents a single operation or recipe for a particular effect. To process a CIImage object, pass it through CIFilter objects. You can subclass CIFilter or draw from the existing library of built-in filters.

Although you can chain filters without separating them into functions, the following example shows how to configure a single CIFilter, the CISepiaTone filter.

func sepiaFilter(_ input: CIImage, intensity: Double) -> CIImage?
{
    let sepiaFilter = CIFilter(name:"CISepiaTone")
    sepiaFilter?.setValue(input, forKey: kCIInputImageKey)
    sepiaFilter?.setValue(intensity, forKey: kCIInputIntensityKey)
    return sepiaFilter?.outputImage
}

To pass the image through the filter, call the sepia filter function.

let sepiaCIImage = sepiaFilter(originalCIImage, intensity:0.9)

You can check the intermediate result at any point in the filter chain by converting from CIImage to the user interface-displayable UIImage and assigning the UIImage to a UIImageView in the view hierarchy.

self.imageView.image = UIImage(ciImage:sepiaCIImage!)

The bloom filter accentuates the highlights of an image. You can apply it as part of a chain without factoring it into a separate function, but this example encapsulates its functionality in a separate function.

func bloomFilter(_ input:CIImage, intensity: Double, radius: Double) -> CIImage?
{
    let bloomFilter = CIFilter(name:"CIBloom")
    bloomFilter?.setValue(input, forKey: kCIInputImageKey)
    bloomFilter?.setValue(intensity, forKey: kCIInputIntensityKey)
    bloomFilter?.setValue(radius, forKey: kCIInputRadiusKey)
    return bloomFilter?.outputImage
}

Like the sepia filter, the intensity of the bloom filter’s effect ranges between 0 and 1, with 1 being the most intense effect. The bloom filter has an additional inputRadius parameter to determine how much the glowing regions will expand. Experiment with a range to values to fine tune the effect, or assign the input parameter to a control like a UISlider to allow your users to tweak its values.

To display the output, convert the CIImage to a UIImage.

let bloomCIImage = bloomFilter(sepiaCIImage, intensity:1, radius:10)
_imageView.image = UIImage(ciImage:bloomCIImage)

Apply the CILanczosScaleTransform to obtain a high-quality downsampling of the image, preserving the original image’s aspect ratio through the CILanczosScaleTransform filter’s input parameter aspectRatio. For built-in Core Image filters, calculate the aspect ratio as the image’s width over height, as in Listing 8.

CGFloat imageWidth = originalUIImage.size.width
CGFloat imageHeight = originalUIImage.size.height
let aspectRatio = Double(originalImage.size.width) / Double(originalImage.size.height)
let scaledCIImage = scaleFilter(bloomCIImage, aspectRatio:aspectRatio, scale:0.5)

Like other built-in filters, the CILanczosScale filter also outputs its result as a CIImage.

func scaleFilter(_ input:CIImage, aspectRatio : Double, scale : Double) -> CIImage
{
    let scaleFilter = CIFilter(name:"CILanczosScaleTransform")!
    scaleFilter.setValue(input, forKey: kCIInputImageKey)
    scaleFilter.setValue(scale, forKey: kCIInputScaleKey)
    scaleFilter.setValue(aspectRatio, forKey: kCIInputAspectRatioKey)
    return scaleFilter.outputImage!
}

self.imageView.image = UIImage(ciImage:scaledCIImage)

In addition to trying out the built-in filters for a fixed effect, you can combine filters in certain Filter Recipes to accomplish tasks such as Applying a Chroma Key Effect, Selectively Focusing on an Image, Customizing Image Transitions, and Simulating Scratchy Analog Film.