Swift Image Processing: Calculate Texture of UIImage as 1 Double - ios

Question

I'm writing an iOs app for image processing and I'm currently developing a method to extract the texture out of a UIImage. The method takes a UIImage as input and gives one value (Double) as output. The higher the texture, the higher the output value will be. That way, input images can be classified from low texture to high texture. Please see Photo 1 to understand the difference between a textured and a smooth image.
Photo 1: Images with high vs low texture
My method is based on the statistical definition of texture (See the PPT presentation of the Purdue University for more info on texture: http://www.cyto.purdue.edu/cdroms/micro2/content/education/wirth06.pdf?fbclid=IwAR0_7ttvNAtVqY9gWkaE_TZhivmXnZIPv1UwByTr8eFW_zAZ_Uxg6kcQ3z0).
Photo 2: Definition of pixel, square, input image
The input images will measure exactly 600px x 600 px. To determine the overall texture of an image, I divide the image into squares which measure 3x3 pixels. From each pixel in the square, I calculate the grayscale value. After that, the minimum and maximum greyscale value is calculated for each square. Finally, the difference is defined as maximum - minimum. This difference is calculated for each 3x3 square in the image. The sum is then made of all those difference values, which gives us the 'Texture'. The higher this sum of differences, the higher the texture in the image. Please see Photo 2 for more info.
First, a pixel, a square and an image are defined in Swift:
struct Pixel {
var value: UInt32
var red: UInt8 {
get { return UInt8(value & 0xFF) }
set { value = UInt32(newValue) | (value & 0xFFFFFF00) }
}
var green: UInt8 {
get { return UInt8((value >> 8) & 0xFF) }
set { value = (UInt32(newValue) << 8) | (value & 0xFFFF00FF) }
}
var blue: UInt8 {
get { return UInt8((value >> 16) & 0xFF) }
set { value = (UInt32(newValue) << 16) | (value & 0xFF00FFFF) }
}
var alpha: UInt8 {
get { return UInt8((value >> 24) & 0xFF) }
set { value = (UInt32(newValue) << 24) | (value & 0x00FFFFFF) }
}
}
struct Square {
var pixels: UnsafeMutableBufferPointer<Pixel>
let width:Int = 3
let height:Int = 3
init?(zeroX: Int, zeroY: Int) {
//pixelArray[0] = UnsafeMutableBufferPointer<Pixel>()
//let coordinates = CGPoint(x: zeroX, y: zeroY)
let bitsPerComponent = 8 // 2
let bytesPerPixel = 4
let bytesPerRow = width * bytesPerPixel
let squareData = UnsafeMutablePointer<Pixel>.allocate(capacity: width * height)
let colorSpace = CGColorSpaceCreateDeviceGray()
var bitmapInfo: UInt32 = CGBitmapInfo.byteOrder32Big.rawValue
bitmapInfo |= CGImageAlphaInfo.premultipliedLast.rawValue & CGBitmapInfo.alphaInfoMask.rawValue
guard let imageContext = CGContext(data: squareData, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo) else { return nil }
//imageContext.draw(cgImage, in: CGRect(origin: .zero, size: image.size))
pixels = UnsafeMutableBufferPointer<Pixel>(start: squareData, count: width * height)
}
}
struct RGBA {
var pixels: UnsafeMutableBufferPointer<Pixel>
var width: Int
var height: Int
init?(image: UIImage) {
guard let cgImage = image.cgImage else { return nil } // 1
width = Int(image.size.width)
height = Int(image.size.height)
let bitsPerComponent = 8 // 2
let bytesPerPixel = 4
let bytesPerRow = width * bytesPerPixel
let imageData = UnsafeMutablePointer<Pixel>.allocate(capacity: width * height)
let colorSpace = CGColorSpaceCreateDeviceRGB() // 3
var bitmapInfo: UInt32 = CGBitmapInfo.byteOrder32Big.rawValue
bitmapInfo |= CGImageAlphaInfo.premultipliedLast.rawValue & CGBitmapInfo.alphaInfoMask.rawValue
guard let imageContext = CGContext(data: imageData, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo) else { return nil }
imageContext.draw(cgImage, in: CGRect(origin: .zero, size: image.size))
pixels = UnsafeMutableBufferPointer<Pixel>(start: imageData, count: width * height)
}
}
Now that those 3 are defined, a method to calculate the difference value of 1 single square is needed:
func getSquareDifference(xValue:Int, yValue:Int) -> Double {
let square = Square(zeroX: xValue, zeroY: yValue)
var whiteValues = [Double]()
for pixel in 0 ... square?.height {
for pixel in 0 .. square?.width {
var white:CGFloat = 0.0
var alpha:CGFloat = 0.0
let index = y * square!.width + x
let pixel = square!.pixels[index]
let pixelColor = UIColor.init(red: CGFloat(pixel.red), green: CGFloat(pixel.green), blue: CGFloat(pixel.blue), alpha: CGFloat(pixel.alpha))
let pixelGreyScaleColor = pixelColor.getWhite(&white, alpha: &alpha)
whiteValues[pixel] = white
}
}
let min = whiteValues.min()
let max = whiteValues.max()
let difference = max - min
return difference
}
Photo 3: For-loop iteration for all 40.000 squares
At last, the program needs to do this getSquareDifference(x,y) method for every square in the image. The first square starts at (0,0), then it needs to shift to the square at (3,0) until the first horizontal line is finished (200 squares). Then it takes the square at (0,3) and does the same thing for the second line. And so on for all the vertical lines (200 squares). Please see Photo 3 for more info.
func determineTexture(inputImage:UIImage) -> Double {
let rgba = RGBA(image: inputImage)
var texture:Double = 0.0
for y in 0..<rgba!.height {
for x in 0..<rgba!.width {
// For all squares, calculate the difference value and add to the Double 'Texture'
// let difference = square.getSquareDifference(x,y)
// texture += difference
}
}
return texture
}
As you cans see, this method is not finished yet. There are still some problems with:
struct Square: How to define the square which upper left pixel is at (x,y)?
func getSquareDifference(x,y) is not yet tested because there are still some problems with the struct square
func determineTexture(inputImage): How to make a for-loop which calculates de 'difference value' of a square, adds that value to 'var texture:Double', shifts to the next square and repeats this process until all difference values of the 40.000 squares (200x200) are calculated.
It would be awesome if someone knows a possible solution to these problems! If this method works, it would be useful for everyone who needs image classification is his/her app.
*Note: if you want to know how to make sure every image measures exactly 600px x 600 px, I would recommend the following method:
let compressedInputImage = inputImage.sd_resizedImage(with: CGSize(width: 600, height: 600), scaleMode: .aspectFill)