Color Cube v2

//
//  ViewController.swift
//  colorCube
//
//  Created by Orkhan Alizade on 17.01.16.
//  Copyright © 2016 Orkhan Alizade. All rights reserved.
//

import UIKit
import Accelerate

class ViewController: UIViewController {
    @IBOutlet var imageView: UIImageView!

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

        imageView.image = UIImage(named: "[email protected]")
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    @IBAction func applyTheFilter(sender: AnyObject) {
        let image: UIImage = UIImage(named: "[email protected]")!

        let ciImage = CIImage(image: image)

//        let filter = CIFilter(name: "CIPhotoEffectMono")

        let filter = colorCubeFilterFromLUT("K1.png")
        filter?.setDefaults()
        filter?.setValue(ciImage, forKey: kCIInputImageKey)

        let outputImage = filter?.outputImage

        let filteredImage = UIImage(CIImage: outputImage!)

        imageView.image = filteredImage
    }



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

        let kDimension : UInt = 64

        let lutImage    = UIImage(named: imageName as String)!.CGImage
        let lutWidth: UInt = UInt(CGImageGetWidth(lutImage!))
        let lutHeight: UInt = UInt(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(Int(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)]) / alpha
                        let green   = Float(bitmap[Int(bitmapOffset+2)]) / alpha
                        let blue    = Float(bitmap[Int(bitmapOffset+3)]) / alpha

                        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()


        var rawData: UInt8 = UnsafePointer<UInt8>(calloc(pixelsHigh * pixelsWide * 4, sizeof(Float))).memory
        var bytesPerPixel: Int = 4
        var bytesPerRow: Int = bytesPerPixel * pixelsWide
        var bitsPerComponent: Int = 8


        // Allocate memory for image data. This is the destination in memory
        // where any drawing to the bitmap context will be rendered.
        let bitmapData = malloc(Int(CUnsignedLong(bitmapByteCount))) // bitmap
        let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.PremultipliedFirst.rawValue | CGBitmapInfo.ByteOrder32Big.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, 512, 512, 8, Int(bitmapBytesPerRow), colorSpace, bitmapInfo.rawValue)


        let rect = CGRect(x:0, y:0, width:1000, height:1000)

        // 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(Int(bitmapByteCount * sizeof(Float)))
        print("BBB \(convertedBitmap)")
        vDSP_vfltu8(UnsafePointer<UInt8>(bitmapData), 1, UnsafeMutablePointer<Float>(convertedBitmap), 1, vDSP_Length(bitmapByteCount))

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