Ios 如何将LUT png用于CIColorCube过滤器？

我想使用查找表png（）作为Swift中

CIColorCube

过滤器的颜色立方体数据。到目前为止，我所尝试（并发现）的都是使用计算颜色立方体的示例，如中所示

如何将png读取为查找数据？

我现在使用并计划将其Objective-C实现用于Swift：

func colorCubeFilterFromLUT(imageName : NSString) -> CIFilter? {

    let kDimension : UInt = 64

    let lutImage    = UIImage(named: imageName)!.CGImage
    let lutWidth    = CGImageGetWidth(lutImage!)
    let lutHeight   = CGImageGetHeight(lutImage!)
    let rowCount    = lutHeight / kDimension
    let columnCount = lutWidth / kDimension

    if ((lutWidth % kDimension != 0) || (lutHeight % kDimension != 0) || (rowCount * columnCount != kDimension)) {

        NSLog("Invalid colorLUT %@", imageName);
        return nil
    }

    let bitmap  = self.createRGBABitmapFromImage(lutImage)
    let size    = Int(kDimension) * Int(kDimension) * Int(kDimension) * sizeof(Float) * 4
    let data    = UnsafeMutablePointer<Float>(malloc(UInt(size)))

    var bitmapOffset : Int = 0
    var z : UInt = 0


    for (var row: UInt = 0; row < rowCount; row++)
    {
        for (var y: UInt = 0; y < kDimension; y++)
        {
            var tmp = z
            for (var col: UInt = 0; col < columnCount; col++)
            {
                for (var x: UInt = 0; x < kDimension; x++) {

                    let alpha   = Float(bitmap[Int(bitmapOffset)]) / 255.0
                    let red     = Float(bitmap[Int(bitmapOffset+1)]) / 255.0
                    let green   = Float(bitmap[Int(bitmapOffset+2)]) / 255.0
                    let blue    = Float(bitmap[Int(bitmapOffset+3)]) / 255.0

                    var dataOffset = Int(z * kDimension * kDimension + y * kDimension + x) * 4

                    data[dataOffset] = red
                    data[dataOffset + 1] = green
                    data[dataOffset + 2] = blue
                    data[dataOffset + 3] = alpha
                    bitmapOffset += 4
                }
                z++
            }
            z = tmp
        }
        z += columnCount
    }

    let colorCubeData = NSData(bytesNoCopy: data, length: size, freeWhenDone: true)

    // create CIColorCube Filter
    var filter = CIFilter(name: "CIColorCube")
    filter.setValue(colorCubeData, forKey: "inputCubeData")
    filter.setValue(kDimension, forKey: "inputCubeDimension")

    return filter
}


func createRGBABitmapFromImage(inImage: CGImage) -> UnsafeMutablePointer<Float> {

    //Get image width, height
    let pixelsWide = CGImageGetWidth(inImage) 
    let pixelsHigh = CGImageGetHeight(inImage) 

    // Declare the number of bytes per row. Each pixel in the bitmap in this
    // example is represented by 4 bytes; 8 bits each of red, green, blue, and
    // alpha.
    let bitmapBytesPerRow = Int(pixelsWide) * 4 
    let bitmapByteCount = bitmapBytesPerRow * Int(pixelsHigh)

    // Use the generic RGB color space.
    let colorSpace = CGColorSpaceCreateDeviceRGB()

    // Allocate memory for image data. This is the destination in memory
    // where any drawing to the bitmap context will be rendered.
    let bitmapData = malloc(CUnsignedLong(bitmapByteCount)) // bitmap
    let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.PremultipliedFirst.rawValue) 

    // Create the bitmap context. We want pre-multiplied RGBA, 8-bits
    // per component. Regardless of what the source image format is
    // (CMYK, Grayscale, and so on) it will be converted over to the format
    // specified here by CGBitmapContextCreate.
    let context = CGBitmapContextCreate(bitmapData, pixelsWide, pixelsHigh, 8, UInt(bitmapBytesPerRow), colorSpace, bitmapInfo)


    let rect = CGRect(x:0, y:0, width:Int(pixelsWide), height:Int(pixelsHigh))        

    // Draw the image to the bitmap context. Once we draw, the memory
    // allocated for the context for rendering will then contain the
    // raw image data in the specified color space.
    CGContextDrawImage(context, rect, inImage)

    // Now we can get a pointer to the image data associated with the bitmap
    // context.
    // var data = CGBitmapContextGetData(context)
    // var dataType = UnsafeMutablePointer<Float>(data)
    // return dataType


    var convertedBitmap = malloc(UInt(bitmapByteCount * sizeof(Float)))
    vDSP_vfltu8(UnsafePointer<UInt8>(bitmapData), 1, UnsafeMutablePointer<Float>(convertedBitmap), 1, vDSP_Length(bitmapByteCount))

    free(bitmapData)
    return UnsafeMutablePointer<Float>(convertedBitmap)
}

func colorCubeFilterFromLUT（imageName:NSString）->CIFilter？{
设kDimension:UInt=64
让lutImage=UIImage（名称：imageName）！.CGImage
让lutWidth=CGImageGetWidth（lutImage！）
让lutwheight=CGImageGetHeight（lutImage！）
让rowCount=luthheight/kDimension
let columnCount=lutWidth/kDimension
if（（lutWidth%kDimension！=0）| |（lutHeight%kDimension！=0）| |（rowCount*columnCount！=kDimension））{
NSLog（“无效的colorLUT%@”，imageName）；
归零
}
让bitmap=self.createRGBABitmapFromImage（lutImage）
设size=Int（kDimension）*Int（kDimension）*Int（kDimension）*sizeof（Float）*4
let data=UnsafeMutablePointer（malloc（UInt（size）））
变量bitmapOffset:Int=0
变量z:UInt=0
对于（变量行：UInt=0；行<行计数；行++）
{
对于（变量y:UInt=0；y不可配置指针{
//获取图像宽度、高度
设pixelsWide=CGImageGetWidth（inImage）
设pixelsHigh=CGImageGetHeight（inImage）
//声明每行的字节数。此对话框中位图中的每个像素
//示例由4个字节表示；红色、绿色、蓝色和蓝色各8位
//阿尔法。
设bitmapBytesPerRow=Int（像素宽度）*4
设bitmapByteCount=bitmapBytesPerRow*Int（像素）
//使用通用RGB颜色空间。
让colorSpace=CGColorSpaceCreateDeviceRGB（）
//为图像数据分配内存。这是内存中的目标
//将渲染位图上下文中的任何图形。
让bitmapData=malloc（CUnsignedLong（bitmapByteCount））//位图
让bitmapInfo=CGBitmapInfo（rawValue:CGImageAlphaInfo.PremultipledFirst.rawValue）
//创建位图上下文。我们需要预乘的RGBA，8位
//每个组件。无论源图像格式是什么
//（CMYK、灰度等）它将转换为
//此处由CGBitmapContextCreate指定。
让context=CGBitmapContextCreate（bitmapData、pixelsWide、pixelsHigh、8、UInt（bitmapBytesPerRow）、颜色空间、bitmapInfo）
设rect=CGRect（x:0，y:0，宽度：Int（像素宽度），高度：Int（像素高度））
//将图像绘制到位图上下文。一旦绘制，内存
//然后，为渲染上下文分配的将包含
//指定颜色空间中的原始图像数据。
CGContextDrawImage（上下文、矩形、inImage）
//现在我们可以得到一个指向与位图关联的图像数据的指针
//上下文。
//var data=CGBitmapContextGetData（上下文）
//var dataType=UnsafeMutablePointer（数据）
//返回数据类型
var convertedBitmap=malloc（UInt（bitmapByteCount*sizeof（Float）））
vDSP_vfltu8（非安全指针（位图数据），1，非安全指针（转换位图），1，vDSP_长度（位图字节计数））
免费（位图数据）
返回不可配置指针（转换位图）
}

---

另见答案

我想我会为Swift 3.0更新这个，这也适用于JPG和PNG的3D彩色LUT

fileprivate func colorCubeFilterFromLUT(imageName : String) -> CIFilter? {

    let size = 64

    let lutImage    = UIImage(named: imageName)!.cgImage
    let lutWidth    = lutImage!.width
    let lutHeight   = lutImage!.height
    let rowCount    = lutHeight / size
    let columnCount = lutWidth / size

    if ((lutWidth % size != 0) || (lutHeight % size != 0) || (rowCount * columnCount != size)) {
        NSLog("Invalid colorLUT %@", imageName);
        return nil
    }

    let bitmap  = getBytesFromImage(image: UIImage(named: imageName))!
    let floatSize = MemoryLayout<Float>.size

    let cubeData = UnsafeMutablePointer<Float>.allocate(capacity: size * size * size * 4 * floatSize)
    var z = 0
    var bitmapOffset = 0

    for _ in 0 ..< rowCount {
        for y in 0 ..< size {
            let tmp = z
            for _ in 0 ..< columnCount {
                for x in 0 ..< size {

                    let alpha   = Float(bitmap[bitmapOffset]) / 255.0
                    let red     = Float(bitmap[bitmapOffset+1]) / 255.0
                    let green   = Float(bitmap[bitmapOffset+2]) / 255.0
                    let blue    = Float(bitmap[bitmapOffset+3]) / 255.0

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

                    cubeData[dataOffset + 3] = alpha
                    cubeData[dataOffset + 2] = red
                    cubeData[dataOffset + 1] = green
                    cubeData[dataOffset + 0] = blue
                    bitmapOffset += 4
                }
                z += 1
            }
            z = tmp
        }
        z += columnCount
    }

    let colorCubeData = NSData(bytesNoCopy: cubeData, length: size * size * size * 4 * floatSize, freeWhenDone: true)

    // create CIColorCube Filter
    let filter = CIFilter(name: "CIColorCube")
    filter?.setValue(colorCubeData, forKey: "inputCubeData")
    filter?.setValue(size, forKey: "inputCubeDimension")

    return filter
}


fileprivate func getBytesFromImage(image:UIImage?) -> [UInt8]?
{
    var pixelValues: [UInt8]?
    if let imageRef = image?.cgImage {
        let width = Int(imageRef.width)
        let height = Int(imageRef.height)
        let bitsPerComponent = 8
        let bytesPerRow = width * 4
        let totalBytes = height * bytesPerRow

        let bitmapInfo = CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Little.rawValue
        let colorSpace = CGColorSpaceCreateDeviceRGB()
        var intensities = [UInt8](repeating: 0, count: totalBytes)

        let contextRef = CGContext(data: &intensities, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo)
        contextRef?.draw(imageRef, in: CGRect(x: 0.0, y: 0.0, width: CGFloat(width), height: CGFloat(height)))

        pixelValues = intensities
    }
    return pixelValues!
}

fileprivate func colorCubeFilterFromLUT（imageName:String）->CIFilter？{
让大小=64
让lutImage=UIImage（名称：imageName）！.cgImage
让lutWidth=luimage！.width
让lutwheight=luimage！.height
让rowCount=高度/大小
let columnCount=lutWidth/大小
if（（lutWidth%size！=0）| |（lutHeight%size！=0）| |（rowCount*columnCount！=size））{
NSLog（“无效的colorLUT%@”，imageName）；
归零
}
让bitmap=getBytesFromImage（image:UIImage（name:imageName））！
让floatSize=MemoryLayout.size
让cubeData=UnsafeMutablePointer.allocate（容量：size*size*size*4*floatSize）
var z=0
var bitmapOffset=0
对于0中的uu..<行计数{
对于0..<尺寸中的y{
设tmp=z
对于0..