Compute the histogram of an image using vImageHistogramCalculation in swift

Question

I'm trying to compute the histogram of an image using Accelerate vImageHistogramCalculation_ARGBFFFF function, but I'm getting a vImage_Error of type kvImageNullPointerArgument (error code is -21772).

This is the exact same question, but I'm working in Swift: Compute the histogram of an image using vImageHistogramCalculation

    // Get CGImage from UIImage
    var image:UIImage = UIImage(named: "happiness1")!
    var img:CGImageRef = image.CGImage

    // Create vImage_Buffer with data from CGImageRef
    var inProvider:CGDataProviderRef = CGImageGetDataProvider(img)
    var inBitmapData:CFDataRef = CGDataProviderCopyData(inProvider)

    // The next three lines set up the inBuffer object
    var height:vImagePixelCount = CGImageGetHeight(img)
    var width:vImagePixelCount = CGImageGetWidth(img)
    var rowBytes:UInt = CGImageGetBytesPerRow(img)
    var data:UnsafePointer<Void> = UnsafePointer<Void>(CFDataGetBytePtr(inBitmapData))

    // Setup inBuffer
    var inBuffer = vImage_Buffer(data: &data, height: height, width: width, rowBytes: rowBytes)

    var histogram_entries:UInt32 = 4
    var minVal:Pixel_F = 0
    var maxVal:Pixel_F = 255
    //let flags:vImage_Flags = kvImageNoFlags = 0

    var histogram = UnsafeMutablePointer<UnsafeMutablePointer<vImagePixelCount>>()

    var error:vImage_Error = vImageHistogramCalculation_ARGBFFFF(&inBuffer, histogram, histogram_entries, minVal, maxVal, 0)

    println(error)

The problem is in the histogram variable, I need to recreate something like this:

// create an array of four histograms with eight entries each.
vImagePixelCount histogram[4][8] = {{0}};  
// vImageHistogramCalculation requires an array of pointers to the histograms.
vImagePixelCount *histogramPointers[4] = { &histogram[0][0], &histogram[1][0], &histogram[2][0], &histogram[3][0] };
vImage_Error error = vImageHistogramCalculation_ARGBFFFF(&inBuffer, histogramPointers, 8, 0, 255, kvImageNoFlags);
// You can now access bin j of the histogram for channel i as histogram[i][j].
// The storage for the histogram will be cleaned up when execution leaves the
// current lexical block.

Suggestion?

Yes, from a vImage standpoint, that is what you need to do. Can't help with the Swift end, alas. Apple might benefit from a bug saying that this is a particularly challenging interface to call from Swift, if the final solution turns out to be arcane enough. I should add that very few image formats naturally produce 32-bit float as their raw image format. Float-tiff, maybe. If you want to control what image format you get out of the CGImage, you should use vImageBuffer_InitWithCGImage(). — Ian Ollmann, Mar 09 '15 at 21:17
Also, with a few exceptions (L* a* b* float images), float images usually range from [0,1] not [0,255]. — Ian Ollmann, Mar 09 '15 at 21:31

Flex Monkey · Answer 1 · 2015-05-26T10:54:08.267

I've implemented vImageHistogramCalculation_ARGB8888 as an extension to UIImage in Swift with the following:

 func SIHistogramCalculation() -> (alpha: [UInt], red: [UInt], green: [UInt], blue: [UInt]) {
   let imageRef = self.CGImage
   let inProvider = CGImageGetDataProvider(imageRef)
   let inBitmapData = CGDataProviderCopyData(inProvider)

   var inBuffer = vImage_Buffer(data: UnsafeMutablePointer(CFDataGetBytePtr(inBitmapData)), height: UInt(CGImageGetHeight(imageRef)), width: UInt(CGImageGetWidth(imageRef)), rowBytes: CGImageGetBytesPerRow(imageRef))

   var alpha = [UInt](count: 256, repeatedValue: 0)
   var red = [UInt](count: 256, repeatedValue: 0)
   var green = [UInt](count: 256, repeatedValue: 0)
   var blue = [UInt](count: 256, repeatedValue: 0)

   var alphaPtr = UnsafeMutablePointer<vImagePixelCount>(alpha)
   var redPtr = UnsafeMutablePointer<vImagePixelCount>(red)
   var greenPtr = UnsafeMutablePointer<vImagePixelCount>(green)
   var bluePtr = UnsafeMutablePointer<vImagePixelCount> (blue)

   var rgba = [redPtr, greenPtr, bluePtr, alphaPtr]

   var histogram = UnsafeMutablePointer<UnsafeMutablePointer<vImagePixelCount>>(rgba)
   var error = vImageHistogramCalculation_ARGB8888(&inBuffer, histogram, UInt32(kvImageNoFlags))
   return (alpha, red, green, blue)
 }

(Taken from https://github.com/FlexMonkey/ShinpuruImage)

This no longer compiles in Xcode 8, Swift 3, get error: "Cannot convert value of type 'UnsafeMutablePointer>' (aka 'UnsafeMutablePointer>') to expected argument type 'UnsafeMutablePointer?>' (aka 'UnsafeMutablePointer>>')" — jbaraga, Sep 17 '16 at 23:08
The line: var rgba = [redPtr, greenPtr, bluePtr, alphaPtr] should be var rgba = [alphaPtr, redPtr, greenPtr, bluePtr] — Bill Chan, Feb 22 '20 at 23:38
In XCode 5, to get around UnsafeMutablePointer warnings, use withUnsafeMutableBufferPoint as shown on this page from Apple: https://developer.apple.com/documentation/accelerate/specifying_histograms_with_vimage — Rethunk, Feb 25 '21 at 14:09

fargofargofargo · Answer 2 · 2020-05-21T15:42:02.453

3

For Swift 5, you need to explicitly let the compiler know that your pointers are optional. Change your UnsafeMutablePointer declarations to the following:

Swift 5 version:

let redPtr = red.withUnsafeMutableBufferPointer { $0.baseAddress }
let greenPtr = green.withUnsafeMutableBufferPointer { $0.baseAddress }
let bluePtr = blue.withUnsafeMutableBufferPointer { $0.baseAddress }
let alphaPtr = alphaChannel.withUnsafeMutableBufferPointer { $0.baseAddress }
let histogram = UnsafeMutablePointer<UnsafeMutablePointer<vImagePixelCount>?>.allocate(capacity: 4)

histogram[0] = redPtr
histogram[1] = greenPtr
histogram[2] = bluePtr
histogram[3] = alphaPtr
let error:vImage_Error = vImageHistogramCalculation_ARGB8888(&inBuffer, histogram, UInt32(kvImageNoFlags))

Swift 4 version:

let redPtr: UnsafeMutablePointer<vImagePixelCount>? = UnsafeMutablePointer(mutating: red)
let greenPtr: UnsafeMutablePointer<vImagePixelCount>? = UnsafeMutablePointer(mutating:green)
let bluePtr: UnsafeMutablePointer<vImagePixelCount>? = UnsafeMutablePointer(mutating:blue)
let alphaPtr: UnsafeMutablePointer<vImagePixelCount>? = UnsafeMutablePointer(mutating:alpha)

edited May 21 '20 at 15:42

answered Mar 04 '20 at 22:55

fargofargofargo

31
3

On Swift 5, this gives warnings. Initialization of 'UnsafeMutablePointer' (aka 'UnsafeMutablePointer') results in a dangling pointer – Gizmodo May 07 '20 at 23:30
1

@Gizmodo Swift 5 added above. – fargofargofargo May 19 '20 at 00:42
On lines of `histogram[0] = redPtr`, I am getting `Expression type '()' is ambiguous without more context ` errors – Gizmodo May 20 '20 at 15:38
1

Does your "red" buffer look like this: `var red = [UInt](repeating: 0, count: 256)` – fargofargofargo May 20 '20 at 19:40
`var red = [vImagePixelCount](repeating: 0, count: 256)` – Gizmodo May 20 '20 at 20:08
1

Ah -- the withUnsafeMutableBufferPointer call should return the pointer ($0.baseAddress) instead. I've fixed it above. – fargofargofargo May 21 '20 at 15:42
Perfect! Works! – Gizmodo May 22 '20 at 20:46

score 0 · Answer 3 · answered May 15 '21 at 16:29

Today, I write the code to analyze photo's RGB histogram. it's working now.

func getHistogram(_ image: UIImage) ->  (alpha: [UInt], red: [UInt], green: [UInt], blue: [UInt]) {
    
        guard
            let cgImage = image.cgImage,
            var imageBuffer = try? vImage_Buffer(cgImage: cgImage)
        else {
            return nil
        }
        defer {
            imageBuffer.free()
        }

        var redArray: [vImagePixelCount] = Array(repeating: 0, count: 256)
        var greenArray: [vImagePixelCount] = Array(repeating: 0, count: 256)
        var blueArray: [vImagePixelCount] = Array(repeating: 0, count: 256)
        var alphaArray: [vImagePixelCount] = Array(repeating: 0, count: 256)
        var error: vImage_Error = kvImageNoError

        redArray.withUnsafeMutableBufferPointer { rPointer in
            greenArray.withUnsafeMutableBufferPointer { gPointer in
                blueArray.withUnsafeMutableBufferPointer { bPointer in
                    alphaArray.withUnsafeMutableBufferPointer { aPointer in

            var histogram = [ rPointer.baseAddress, gPointer.baseAddress, bPointer.baseAddress, aPointer.baseAddress ]
            histogram.withUnsafeMutableBufferPointer { hPointer in
              
              if let hBaseAddress = hPointer.baseAddress {
                
                error = vImageHistogramCalculation_ARGB8888(&imageBuffer, hBaseAddress, vNoFlags)
                            }
                        }
                    }
                }
            }
        }

        guard error == kvImageNoError else {
            printVImageError(error: error)
            return nil
        }
        
  
        return (alphaArray, redArray, greenArray, blueArrat)
    }

Compute the histogram of an image using vImageHistogramCalculation in swift

3 Answers3