【转载】OpenCV性能衡量与优化方法(十二）

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

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

cv.getTickCount（）

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

cv.getTickFrequency（）

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

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

	view plaincopy to clipboardprint?
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，我们看看效果，当然，这里只是进行一个实验，具体代码的编写目前并不要求大家掌握，这些是后面将要学到的内容，我们来看代码：

	view plaincopy to clipboardprint?
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（）来启用/禁用它：

view plaincopy to clipboardprint?
import cv2  
  
print(cv2.useOptimized())  
cv2.setUseOptimized(False)  
print(cv2.useOptimized())  

我们可以查看输出：

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

	view plaincopy to clipboardprint?
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())  

时间：

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

	view plaincopy to clipboardprint?
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基础篇的讲解。
查看文章汇总页https://blog.csdn.net/weixin_44237705/article/details/107864965
更多openvino技术信息可以入群交流~