Chiper - 滤镜开发

Core Image 是苹果自带的图像处理库，能够非常简单的实现基本的滤镜效果，最新的iOS 10 已经自带超过180种滤镜，基本可以满足绝大部分的滤镜需求。

基本滤镜

基本使用

System Filter的使用是非常简单的，都是通过CIFilter这个类来生成滤镜实例。

例如系统滤镜Chrome的创建如下：

let filterClassName = "CIPhotoEffectChrome"
let filterContext = [String:Any]()
let filter = CIFilter(name: filterClassName, withInputParameters: filterContext)

不用传参的自带滤镜效果

• CIPhotoEffectChrome
• CIPhotoEffectFade
• CIPhotoEffectInstant
• CIPhotoEffectMono
• CIPhotoEffectNoir
• CIPhotoEffectProcess
• CIPhotoEffectTonal
• CIPhotoEffectTransfer
• CILinearToSRGBToneCurve
• CISRGBToneCurveToLinear

高级滤镜

仅仅使用System的基本滤镜是不够的，特别对于一些高级效果，只靠一个基本滤镜是没办法创建的。因此，使用可以考虑使用基本滤镜的组合，即滤镜链来实现一些基本滤镜不能实现的效果。例如Chiper中19th的效果，就是好几个基本滤镜组合而成的。

WechatIMG32.jpeg

一般来说，滤镜链的实现都是将一个滤镜的输出，作为另一个滤镜的输入，通过这种串联的方式，来实现滤镜的的叠加的。但是当串联的滤镜数越来越多的时候，势必会影响整个滤镜链的性能，所以不建议串联太多滤镜。

3D-LUTs 滤镜

基本概念

除了滤镜链的方式外，还有一种更便捷的滤镜实现方式 --- LUT。

如下图所示，这是一张Original Lookup Table，所有颜色都没进行变换。

经过一系列调整后，LUT色彩变换成这样：

使用 & 原理

使用LUT的滤镜是如何工作的？

LUT其实是一张颜色映射表，执行滤镜算法的时候，此算法会对Image的每个像素执行颜色映射（根据Image的R,G,B,A在LUT上进行颜色查找），这样就能对整个图像的色调进行改变，达到滤镜的效果。

LUT的核心算法如下：

   public static func createColorCubeData(inputImage image: UIImage, cubeDimension: Int) throws -> Data {
        
        let imageSize = image.size
        let dim = Int(imageSize.width)
        let pixels = dim * dim
        let channels = 4 //r,g,b,a (4 channels)

        guard pixels == cubeDimension * cubeDimension * cubeDimension else {
            throw ColorCubeError.incorrectImageSize
        }
        
        let memSize = pixels * channels
        
        guard let img = image.cgImage else {
            throw ColorCubeError.missingImageData
        }
        
        guard let inProvider = img.dataProvider else {
            throw ColorCubeError.unableToCreateDataProvider
        }
        
        let inBitmapData = inProvider.data
        guard let inBuffer = CFDataGetBytePtr(inBitmapData) else {
            throw ColorCubeError.unableToGetBitmpaDataBuffer
        }
    
        let floatSize = memSize * MemoryLayout.size
        let finalBuffer = unsafeBitCast(malloc(floatSize), to:UnsafeMutablePointer.self)

        let width = image.cgImage!.width
        let height = image.cgImage!.height
        let rowNum = width / cubeDimension
        let columnNum = height / cubeDimension
        var bitmapOffest: Int = 0
        var z: Int = 0
        var array = Array(repeating: 0, count: floatSize)

        let bitmap = inBuffer
        for _ in stride(from: 0, to: rowNum, by: 1) {
            for y in stride(from: 0, to: cubeDimension, by: 1) {
                let tmp = z
                for _ in stride(from: 0, to: columnNum, by: 1) {
                    for x in stride(from: 0, to: cubeDimension, by: 1) {

                        let dataOffset = (z * cubeDimension * cubeDimension + y * cubeDimension + x) * 4

                        let position = bitmap
                            .advanced(by: bitmapOffest)

                        array[dataOffset + 0] = Float(position
                            .advanced(by: 0)
                            .pointee) / 255

                        array[dataOffset + 1] = Float(position
                            .advanced(by: 1)
                            .pointee) / 255

                        array[dataOffset + 2] = Float(position
                            .advanced(by: 2)
                            .pointee) / 255

                        array[dataOffset + 3] = Float(position
                            .advanced(by: 3)
                            .pointee) / 255

                        bitmapOffest += 4

                    }
                    z += 1
                }
                z = tmp
            }
            z += columnNum
        }
        let data = Data.init(bytes: array, count: floatSize)
        return data
    }

将变换后的Data传入CIColorCube滤镜中，即可实现滤镜效果。

参考

GPUImage - 颜色查找表(Color Lookup Table) 为图片添加滤镜
[iOS] 使用CIColorCube快速製作濾鏡