用加速平均像素的颜色

Question

是的，我知道使用 CIAreaAverate CIFilter获取像素的平均颜色。

我正在尝试使用Accelerate Framework创建一些替代方案，以查看我是否可以更快地使用。

我将CIImage渲染到上下文。为此，我有这个CIImage extension ...

let device: MTLDevice = MTLCreateSystemDefaultDevice()!
let context = CIContext.init(mtlDevice: device, options: [.workingColorSpace: kCFNull])
let w = self.extent.width
let h = self.extent.height
let size = w * h * 4
var bitmap = [UInt8](repeating: 0, count:Int(size))

context.render(self,
                      toBitmap: &bitmap,
                      rowBytes: 4 * Int(w),
                      bounds: self.extent,
                      format: .BGRA8,
                      colorSpace: nil)

此时，我的bitmap包含BGRA字节交错。

要获得R，G和B的平均值，我要做的就是这样的事情：

var averageBlue : Int = 0
for x in stride(from:0, through: bitmap.count-4, by: 4) {
  let value = bitmap[Int(x)]
  averageBlue += Int(value)
}
averageBlue /= numberOfPixels

但是，此for环路的地狱很慢，如预期的。

我正在考虑使用一些Accelerate功能，例如

vDSP_meanvD(bitmap, 2, &r, vDSP_Length(numberOfPixels))

但是此功能要求bitmap是UnsafePointer<Double>的数组...

我可以将bitmap转换为此，但这需要for循环，这很慢。

是否有任何方法可以提取这些R，G和B像素，并使用一些加速的东西进行平均值？

Answer 1

您可以使用vDSP_vfltu8(_:_:_:_:_:)：

将bitmap转换为单精度浮点数值

let bitmap: [UInt8] = [1, 10,  50,  0,
                       2, 20, 150,  5,
                       3, 30, 250, 10]
//Blue
var blueFloats = [Float](repeating: 0, count: bitmap.count/4)
vDSP_vfltu8(bitmap,
            vDSP_Stride(4),
            &blueFloats,
            vDSP_Stride(1),
            vDSP_Length(blueFloats.count))

然后使用vDSP_meanv(_:_:_:_:)：

var blue: Float = 0
vDSP_meanv(blueFloats,
           vDSP_Stride(1),
           &blue,
           vDSP_Length(blueFloats.count))
print("blue =", blue)     //2.0

关于红色：

//Red
var redFloats = [Float](repeating: 0, count: bitmap.count/4)
vDSP_vfltu8(UnsafePointer.init(bitmap).advanced(by: 2),
            vDSP_Stride(4),
            &redFloats,
            vDSP_Stride(1),
            vDSP_Length(redFloats.count))
var red: Float = 0
vDSP_meanv(redFloats,
           vDSP_Stride(1),
           &red,
           vDSP_Length(redFloats.count))
print("red =", red) //150.0

Answer 2

就像iyelamani所说的那样，您可以使用vDSP_vfltu8有效地构建Float的缓冲区。

但是，您还可以使用cblas_sgemv（或cblas_sgemm）来计算单个呼叫中的所有四个平均值：

，而不是四次大步浏览该数组。

let pixelCount: Int = width * height
let channelsPerPixel: Int = 4
let m: Int32 = Int32(channelsPerPixel)
let n: Int32 = Int32(pixelCount)
let lda = m
var a = [Float](repeating: 0, count: pixelCount * channelsPerPixel)
vDSP_vfltu8(pixelBuffer, vDSP_Stride(1), &a, vDSP_Stride(1), vDSP_Length(pixelCount * channelsPerPixel))
var x = [Float](repeating: 1 / Float(pixelCount), count: pixelCount)
var y = [Float](repeating: 0, count: channelsPerPixel)
cblas_sgemv(CblasColMajor, CblasNoTrans, m, n, 1, &a, lda, &x, 1, 1, &y, 1)
print(y)