EEPW论坛

OpenCV性能衡量与优化方法

本次教程我们谈及OpenCV的性能衡量与优化，众所周知，算法的不断的革新其最重要的一点就是不断的优化再优化，比如我们的后面要讲到的边缘检测的算法，又或者是图像分割的算法，他们都是随着时间的一步一步的推移，从而完成算法层面的优化。在以后的学习中，我们会接触到诸多的框架，这些所谓的API他们都是固定的，如果我们只是单纯的调用这些API的话，那么就做不到算法层面的革新，而当我们自己想从原理层面来写这些算法的时候，我们就需要考虑到它的速度，是否能跟得上这些原有API的速度。

本次教程我们需要接触到几个函数：

cv.getTickCount（）

调用此函数之后返回时钟周期的数目。因此，如果在函数执行之前和之后调用它，则会获得用于执行函数的时钟周期数。

cv.getTickFrequency（）

函数返回时钟周期的频率，或每秒时钟周期的数目。

现在我们来做个实验，我们采用一个普通的高斯滤波器，调用OpenCV中的函数API，我们看看调用OpenCV的API速度怎么样：

import cv2

img1 = cv2.imread("01.jpg")

e1 = cv2.getTickCount()
img1 = cv2.GaussianBlur(img1,(3,3),0)
e2 = cv2.getTickCount()
t = (e2 - e1) / cv2.getTickFrequency()
print(t)
cv2.imshow("res", img1)
cv2.waitKey(0)
cv2.destroyAllWindows()

我们运行看看效果：

可以看到运行速度非常快，现在我们自己写一个高斯滤波器，不再调用官方API，我们看看效果，当然，这里只是进行一个实验，具体代码的编写目前并不要求大家掌握，这些是后面将要学到的内容，我们来看代码：

import cv2
import numpy as np
import math
import copy

gauss = np.array([1, 2, 1, 2, 4, 2, 1, 2, 1])


def spilt(a):
    if a / 2 == 0:
        x1 = x2 = a / 2
    else:
        x1 = math.floor(a / 2)
        x2 = a - x1
    return -x1, x2


def gaussian_b0x(a, b):
    judge = 10
    sum = 0
    box = []
    x1, x2 = spilt(a)
    y1, y2 = spilt(b)
    for i in range(x1, x2):
        for j in range(y1, y2):
            t = i * i + j * j
            re = math.e ** (-t / (2 * judge * judge))
            sum = sum + re
            box.append(re)

    box = np.array(box)
    box = box / sum
    # for x in box :
    #     print (x)
    return box


def original(i, j, k, a, b, img):
    x1, x2 = spilt(a)
    y1, y2 = spilt(b)
    temp = np.zeros(a * b)
    count = 0
    for m in range(x1, x2):
        for n in range(y1, y2):
            if i + m < 0 or i + m > img.shape[0] - 1 or j + n < 0 or j + n > img.shape[1] - 1:
                temp[count] = img[i, j, k]
            else:
                temp[count] = img[i + m, j + n, k]
            count += 1
    return temp


def gaussian_function(a, b, img, gauss_fun):
    img0 = copy.copy(img)
    for i in range(0, img.shape[0]):
        for j in range(2, img.shape[1]):
            for k in range(img.shape[2]):
                temp = original(i, j, k, a, b, img0)
                img[i, j, k] = np.average(temp, weights=gauss_fun)  # 按权分配
    return img


img0 = cv2.imread("01.jpg")
gauss_new = gaussian_b0x(3 , 3)
e1 = cv2.getTickCount()
gauss_img = gaussian_function(3, 3, copy.copy(img0), copy.copy(gauss_new))
e2 = cv2.getTickCount()
t = (e2 - e1) / cv2.getTickFrequency()
print(t)
cv2.imshow("res",gauss_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

我们来看运行效果，跟官方API的效果一致：

但是其运行时间让人觉得难以接受，竟然长达18秒：

由此我们可以用这两个函数检验自己所写的算法是否已经足够优化，运行时间就是最好的证明。

OpenCV中的默认优化

许多OpenCV功能都使用SSE2，AVX等进行了优化，当然它也包含未经优化的代码。 因此，如果我们的系统支持这些功能，我们应该利用它们（几乎所有现代处理器都支持它们）.编译时默认启用它， 因此，OpenCV运行优化代码（如果已启用），否则运行未优化代码。 我们可以使用cv2.useOptimized（）来检查它是否已启用/禁用，并使用cv2.setUseOptimized（）来启用/禁用它：

import cv2

print(cv2.useOptimized())
cv2.setUseOptimized(False)
print(cv2.useOptimized())

我们可以查看输出：

现在我们将其综合起来，看看优化之后与不优化的速度差异，我们先来看优化之后的：

import cv2

img1 = cv2.imread("cat.jpg")
print(cv2.useOptimized())  # True
e1 = cv2.getTickCount()
for i in range(5, 49, 2):
    img1 = cv2.medianBlur(img1, i)
e2 = cv2.getTickCount()
print((e2 - e1) / cv2.getTickFrequency())

时间：

我们再来看看未优化的效果：

import cv2

img1 = cv2.imread("cat.jpg")
cv2.setUseOptimized(False)
print(cv2.useOptimized())  # False
e1 = cv2.getTickCount()
for i in range(5, 49, 2):
    img1 = cv2.medianBlur(img1, i)
e2 = cv2.getTickCount()
print((e2 - e1) / cv2.getTickFrequency())

事实证明，OpenCV在开启优化之后其运行速度得到了提升。

到本次教程为止，OpenCV入门篇的教程就结束了，从下一个教程开始，将进行OpenCV基础篇的讲解。