Усреднение цвета пикселей с ускорением - PullRequest
Новая
       58

Усреднение цвета пикселей с ускорением

1 голос
/ 11 марта 2019

Да, я знаю об использовании 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 иБ, все, что мне нужно сделать, это что-то вроде этого: 

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 и получить их индивидуальные средние значения, используя некоторые ускоряющие функции?

Ответы [ 2 ]

1 голос
/ 12 марта 2019

Как сказал ielyamani, вы можете использовать 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)
1 голос
/ 12 марта 2019

Вы можете преобразовать bitmap в значения с плавающей точкой одинарной точности, используя vDSP_vfltu8(_:_:_:_:_:): 

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
...