Looping through pixels in images

Question

I wrote the following function:

    class func convertImageToBlackAndWhite(#data:UnsafeMutablePointer<UInt32>, inputWidth:UInt32, inputHeight:UInt32) -> UnsafeMutablePointer<UInt32> {
    var currentPixel = UnsafeMutablePointer<UInt32>()
    currentPixel = data

    for (var i = 0; i < Int(inputHeight); i++) {
        for (var j = 0; j < Int(inputWidth); j++) {
            var color:UInt32 = currentPixel.memory

            // Average of RGB = greyscale
            var averageColor:UInt32 = (R(color) + G(color) + B(color)) / 3
            var updatedColor:UInt32 = RGBAMake(averageColor, g: averageColor, b: averageColor, a: A(color))
            currentPixel.memory = updatedColor
            currentPixel++
        }
    }

    var outputData = UnsafeMutablePointer<UInt32>((calloc(UInt(inputHeight*inputWidth), UInt(sizeof(UInt32)))))
    outputData = currentPixel
    return outputData
}

I want to return outputData to display it on the screen. Therefore, I created this code as part of another function:

    class func processUsingPixels(#inputImage:UIImage) -> UIImage {

    var inputCGImage:CGImageRef = inputImage.CGImage
    var colorSpace:CGColorSpaceRef = CGColorSpaceCreateDeviceRGB()
    var inputWidth:UInt = CGImageGetWidth(inputCGImage)
    var inputHeight:UInt = CGImageGetHeight(inputCGImage)
    var bytesPerPixel:UInt = 4
    var bitsPerComponent:UInt = 8
    var inputBytesPerRow = bytesPerPixel * inputWidth

    let bitmapInfo = CGBitmapInfo(CGBitmapInfo.ByteOrder32Big.rawValue | CGImageAlphaInfo.PremultipliedLast.rawValue)

    let inputPixels = UnsafeMutablePointer<UInt32>(calloc(UInt(inputHeight*inputWidth), UInt(sizeof(UInt32))))

    var outputData = UnsafeMutablePointer<UInt32>()
    outputData = self.convertImageToBlackAndWhite(data: inputPixels, inputWidth: UInt32(inputWidth), inputHeight: UInt32(inputHeight))


    let context:CGContextRef = CGBitmapContextCreate(outputData, inputWidth, inputHeight, bitsPerComponent, inputBytesPerRow, colorSpace, bitmapInfo)
    CGContextDrawImage(context, CGRectMake(0, 0, CGFloat(inputWidth), CGFloat(inputHeight)), inputCGImage)


    return inputImage
}

DataData is the data that I now wanted to display. I expected that the changes in the for-loop in "ConvertImageToBlackAndWhite" would be reflected, but no changes would occur at all.

Thanks to Rob, I got valuable information before. but this picture does not change at all.

my questions will be as follows:

1) Is it right to create this var output as a return value? Does that make sense at all?

2) OutputData Variable, . . ? processusingPixels - UIImage. , CGContextDrawImage . ?

Answer 1

currentPixel for. , :

var currentPixel = inputPixels

for row in 0 ..< inputHeight {
    for column in 0 ..< inputWidth {
        var color: UInt32 = currentPixel.memory
        print(String(format:"%X", color))
        currentPixel++
    }
}

---

, CGBitmapContextCreateImage:

func processUsingPixels(inputImage inputImage: UIImage) -> UIImage {
    let inputCGImage = inputImage.CGImage
    let colorSpace = CGColorSpaceCreateDeviceRGB()
    let width = CGImageGetWidth(inputCGImage)
    let height = CGImageGetHeight(inputCGImage)
    let bytesPerPixel: UInt = 4
    let bitsPerComponent: UInt = 8
    let bytesPerRow = bytesPerPixel * width
    let bitmapInfo = CGBitmapInfo.ByteOrder32Big.rawValue | CGImageAlphaInfo.PremultipliedLast.rawValue

    let context:CGContextRef = CGBitmapContextCreate(nil, width, height, bitsPerComponent, bytesPerRow, colorSpace, bitmapInfo)
    CGContextDrawImage(context, CGRectMake(0, 0, CGFloat(width), CGFloat(height)), inputCGImage)

    let pixelBuffer = UnsafeMutablePointer<UInt32>(CGBitmapContextGetData(context))

    var currentPixel = pixelBuffer

    for row in 0 ..< inputHeight {
        for column in 0 ..< inputWidth {
            currentPixel.memory = grayScaleFromColor(currentPixel.memory)
            currentPixel++
        }
    }

    let outputCGImage = CGBitmapContextCreateImage(context)
    return UIImage(CGImage: outputCGImage)!
}

func grayScaleFromColor(color: UInt32) -> UInt32 {
    let r = Double(red(color))
    let g = Double(green(color))
    let b = Double(blue(color))
    let a = alpha(color)

    let gray = UInt8(0.2126 * r + 0.7152 * g + 0.0722 * b)

    return rgba(red: gray, green: gray, blue: gray, alpha: a)
}

, calloc . , , free.

---

RGBA UInt32, RGBA. :

func red(color: UInt32) -> UInt8 {
    return UInt8(color & 255)
}

func green(color: UInt32) -> UInt8 {
    return UInt8((color >> 8) & 255)
}

func blue(color: UInt32) -> UInt8 {
    return UInt8((color >> 16) & 255)
}

func alpha(color: UInt32) -> UInt8 {
    return UInt8((color >> 24) & 255)
}

func rgba(#red: UInt8, green: UInt8, blue: UInt8, alpha: UInt8) -> UInt32 {
    return UInt32(red) | (UInt32(green) << 8) | (UInt32(blue) << 16) | (UInt32(alpha) << 24)
}

, , , struct (, , PremultipliedFirst, PremultipliedLast, , ). / , .