import Foundation
import CoreImage
import UIKit
// 封装 Core Image
// 我们应该谨慎地选择类型，这比其他任何事都重要，因为类型将左右开发流程
typealias Filter = (CIImage) -> CIImage
构建滤镜
// 1.高斯模糊滤镜，定义它只需要模糊半径这一个参数
func blur(radius: Double) -> Filter {
return { image in
let parameters = [kCIInputRadiusKey: radius,kCIInputImageKey: image] as [String : Any]
guard let filter = CIFilter(name: "CIGaussianBlur", parameters: parameters) else { fatalError() }
guard let outputImage = filter.outputImage else { fatalError() }
return outputImage
}
}
blur 函授返回一个新函数，新函数接受一个 CIImage 类型的参数 image， 并返回一个新图像（return filter.outputImage）。因此blur 函数的返回值满足我们之前定义的 CIImage -> CIImage，也就是 Filter 类型。
// 2.颜色叠层，将使用的两个基础组件:颜色生成滤镜 (CIConstantColorGenerator) 和图像覆盖合成滤镜 (CISourceOverCompositing)
// 定义一个生成固定颜色的滤镜
func colorGenerator(color: CGColor) -> Filter {
return { _ in // 颜色生成滤镜不检查输入图像
let c = CIColor(cgColor: color)
let parameters = [kCIInputColorKey: c]
guard let filter = CIFilter(name: "CIConstantColorGenerator", parameters: parameters) else { fatalError() }
guard let outputImage = filter.outputImage else { fatalError() }
return outputImage
}
}
// 定义一个合成滤镜
func compositeSourceOver(overlay: CIImage) -> Filter {
return { image in
let parameters = [kCIInputBackgroundImageKey: image, kCIInputImageKey: overlay]
guard let filter = CIFilter(name: "CISourceOverCompositing", parameters: parameters) else { fatalError() }
guard let outputImage = filter.outputImage else { fatalError() }
let cropRect = image.extent
return outputImage.cropped(to: cropRect)
}
}
// 通过结合两个滤镜来创建颜色叠层滤镜：
func colorOverlay(color: CGColor) -> Filter {
return { image in
let overlay = colorGenerator(color: color)(image)
return compositeSourceOver(overlay: overlay)(image)
}
}
colorOverlay 函数首先调用了 colorGenerator 滤镜。colorGenerator 滤镜需要一个 color 作为参数，然后返回一个新的滤镜，因此代码片段colorGenerator(color) 是 Filter 类型。而 Filter 类型本身就是一个从 CIImage 到 CIImage 的 函数;因此我们可以向 colorGenerator(color) 函数传递一个附加的 CIImage 类型的参数，最终我们能够得到一个 CIImage 类型的新叠层。这就是我们在定义 overlay 的过程中所发生的全部 事情事，可以大致概括为 ——首先使用colorGenerator函数创建一个滤镜，接着向这个滤镜 传递一个 image 参数来创建新图像。与之类似，返回值 compositeSourceOver(overlay)(image) 由一个通compositeSourceOver(overlay) 函数构建 的滤镜和随即被作为参数的 image 组成。
组合滤镜
let url = URL(string: "http://www.objc.io/images/covers/16.jpg")!
let image = CIImage(contentsOf: url)
let blurRadius = 5.0
let blurredImage = blur(radius: blurRadius)(image!)
let overlayColor = UIColor.red.cgColor
let overlaidImage = colorOverlay(color: overlayColor)(blurredImage)
// or
let resultImage = colorOverlay(color: overlayColor)(blur(radius: blurRadius)(image!))
// or
func composeFilters(filter1: @escaping Filter, filter2: @escaping Filter) -> Filter {
return { image in filter2(filter1(image))}
}
let composeFilter1 = composeFilters(filter1: blur(radius: blurRadius), filter2: colorOverlay(color: overlayColor))
let composeResultImage1 = composeFilter1(image!)
// 为组合滤镜引入运算符
precedencegroup toRightPrecedence {
associativity: left // 左结合
higherThan: AdditionPrecedence
lowerThan: MultiplicationPrecedence
}
// 由于已经定义的运算符 >>> 是左结合的 (left-associative)，就像 Unix 的管道一样，滤镜将以从左到右的顺序被应用到图像上。
infix operator >>> : toRightPrecedence
func >>> (filter1: @escaping Filter, filter2: @escaping Filter) -> Filter {
return { image in filter2(filter1(image))}
}
let composeFilter2 = blur(radius: blurRadius) >>> colorOverlay(color: overlayColor)
let composeResultImage2 = composeFilter2(image!)
理论背景 -- 柯里化
func addExample1(x: Int, y: Int) -> Int {
return x + y
}
func addExample2(x: Int) -> ((Int) -> Int) {
return { y in return x + y }
}
addExample1(x: 1, y: 2)
addExample2(x: 1)(2)
let num = 100
func add2To(x: Int) -> Int {
return x + 2
}
func add3To(x: Int) -> Int {
return x + 3
}
func addYto(x: Int) -> ((Int) -> Int) {
return { y in return x + y }
}
add2To(x: num)
add3To(x: num)
// 和上面两个调用相同，但是只用一个函数即可完成
addYto(x: num)(2)
addYto(x: num)(3)
完整代码
import Foundation
import CoreImage
import UIKit
// 封装 Core Image
// 我们应该谨慎地选择类型，这比其他任何事都重要，因为类型将左右开发流程
typealias Filter = (CIImage) -> CIImage
/* 构建滤镜 */
// 1.高斯模糊滤镜，定义它只需要模糊半径这一个参数
func blur(radius: Double) -> Filter {
return { image in
let parameters = [kCIInputRadiusKey: radius,kCIInputImageKey: image] as [String : Any]
guard let filter = CIFilter(name: "CIGaussianBlur", parameters: parameters) else { fatalError() }
guard let outputImage = filter.outputImage else { fatalError() }
return outputImage
}
}
/* blur 函授返回一个新函数，新函数接受一个 CIImage 类型的参数 image， 并返回一个新图像（return filter.outputImage）。因此blur 函数的返回值满足我们之前定义的 CIImage -> CIImage，也就是 Filter 类型。*/
// 2.颜色叠层，将使用的两个基础组件:颜色生成滤镜 (CIConstantColorGenerator) 和图像覆盖合成滤镜 (CISourceOverCompositing)
// 定义一个生成固定颜色的滤镜
func colorGenerator(color: CGColor) -> Filter {
return { _ in // 颜色生成滤镜不检查输入图像
let c = CIColor(cgColor: color)
let parameters = [kCIInputColorKey: c]
guard let filter = CIFilter(name: "CIConstantColorGenerator", parameters: parameters) else { fatalError() }
guard let outputImage = filter.outputImage else { fatalError() }
return outputImage
}
}
// 定义一个合成滤镜
func compositeSourceOver(overlay: CIImage) -> Filter {
return { image in
let parameters = [kCIInputBackgroundImageKey: image, kCIInputImageKey: overlay]
guard let filter = CIFilter(name: "CISourceOverCompositing", parameters: parameters) else { fatalError() }
guard let outputImage = filter.outputImage else { fatalError() }
let cropRect = image.extent
return outputImage.cropped(to: cropRect)
}
}
// 通过结合两个滤镜来创建颜色叠层滤镜：
func colorOverlay(color: CGColor) -> Filter {
return { image in
let overlay = colorGenerator(color: color)(image)
return compositeSourceOver(overlay: overlay)(image)
}
}
/* colorOverlay 函数首先调用了 colorGenerator 滤镜。colorGenerator 滤镜需要一个 color 作为参数，然后返回一个新的滤镜，因此代码片段colorGenerator(color) 是 Filter 类型。而 Filter 类型本身就是一个从 CIImage 到 CIImage 的 函数;因此我们可以向 colorGenerator(color) 函数传递一个附加的 CIImage 类型的参数，最终我们能够得到一个 CIImage 类型的新叠层。这就是我们在定义 overlay 的过程中所发生的全部 事情事，可以大致概括为 ——首先使用colorGenerator函数创建一个滤镜，接着向这个滤镜 传递一个 image 参数来创建新图像。与之类似，返回值 compositeSourceOver(overlay)(image) 由一个通过 compositeSourceOver(overlay) 函数构建 的滤镜和随即被作为参数的 image 组成。*/
/* 组合滤镜 */
let url = URL(string: "http://www.objc.io/images/covers/16.jpg")!
let image = CIImage(contentsOf: url)
let blurRadius = 5.0
let blurredImage = blur(radius: blurRadius)(image!)
let overlayColor = UIColor.red.cgColor
let overlaidImage = colorOverlay(color: overlayColor)(blurredImage)
// or
let resultImage = colorOverlay(color: overlayColor)(blur(radius: blurRadius)(image!))
// or
func composeFilters(filter1: @escaping Filter, filter2: @escaping Filter) -> Filter {
return { image in filter2(filter1(image))}
}
let composeFilter1 = composeFilters(filter1: blur(radius: blurRadius), filter2: colorOverlay(color: overlayColor))
let composeResultImage1 = composeFilter1(image!)
// 为组合滤镜引入运算符
precedencegroup toRightPrecedence {
associativity: left // 左结合
higherThan: AdditionPrecedence
lowerThan: MultiplicationPrecedence
}
// 由于已经定义的运算符 >>> 是左结合的 (left-associative)，就像 Unix 的管道一样，滤镜将以从左到右的顺序被应用到图像上。
infix operator >>> : toRightPrecedence
func >>> (filter1: @escaping Filter, filter2: @escaping Filter) -> Filter {
return { image in filter2(filter1(image))}
}
let composeFilter2 = blur(radius: blurRadius) >>> colorOverlay(color: overlayColor)
let composeResultImage2 = composeFilter2(image!)
/* 理论背景 -- 柯里化*/
func addExample1(x: Int, y: Int) -> Int {
return x + y
}
func addExample2(x: Int) -> ((Int) -> Int) {
return { y in return x + y }
}
addExample1(x: 1, y: 2)
addExample2(x: 1)(2)
let num = 100
func add2To(x: Int) -> Int {
return x + 2
}
func add3To(x: Int) -> Int {
return x + 3
}
func addYto(x: Int) -> ((Int) -> Int) {
return { y in return x + y }
}
add2To(x: num)
add3To(x: num)
// 和上面两个调用相同，但是只用一个函数即可完成
addYto(x: num)(2)
addYto(x: num)(3)
// ___
// //|||\\
// //|-_-|\\
// |||
// |
// |
// / \