[PYTHON] Image capture / OpenCV speed comparison with and without GPU

Overview

Recently, I made a new PC. Before, when I was playing with OpenCV, the fps of image processing was only about 10 fps, and I thought it was subtle, so I will try to find out what it looks like by changing the PC. Next, I will compare the GPU with the GTX1660super and Intel built-in graphics.

I think someone is already doing it, but I couldn't find it, so I'm writing it. Please let me know if there are other articles doing the same thing. I want to read.

environment

• Python3 (Introducing anaconda3-Run on Spyder)
• Windows 10 Home 64bit

PC specifications to be compared

Old PC

• core i5-6200U @2.3GHz 2core-4threads
• Intel HD Graphics 520
• 12GB memory
• SSD

New PC-Built-in GPU

• core i9-9900k @3.6GHz 8core-16threads
• Intel HD Graphics 630
• SSD

New PC-GPU

• core i9-9900k @3.6GHz
• Zotac GTX1660-super
• SSD

Cine-bench R20 result

It doesn't depend on GPU at all.

FFXV_bench 1920 * 1080, standard quality

The memory is barely enough, and it's useless without a GPU.

Image capture bench

Image capture (using mss library)

You can capture screens in a library called mss.

pip install mss

Is required. Get the elapsed time $ [s] $ in a library called time. Compare the time it took to capture the screen 1000 times. I don't know where the bottleneck is. If you loop $ while $ without acquiring the image, it could not be measured at the second level, so the image capture part

sct.grab(monitor)

I think there is no doubt that it takes time.

This is expected because the refresh rate of the display connected to the PC is set to 59.94Hz.

capture_test.py

import cv2			#OpenCV library
import numpy as np		#Numpy library
from mss import mss
import time

sct = mss()

"""
For operation check: Comment out after operation check
"""
#windowName = "capture"
#cv2.namedWindow(windowName)

n= 0
while True:
    if n == 0:
        start_time = time.time()
        
    if n>= 1000:  #Repeated 1000 times
        end_time = time.time()
        break
    """
Image acquisition
    """        
    monitor = {"top": 300, "left": 170, "width": 600, "height": 200}
    img = np.array(sct.grab(monitor))
    
    """
Operation check part
    """
    """
    img = img[:,:,0:3]
    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
    img = np.asarray(img)
    cv2.imshow(windowName,img)
    key = cv2.waitKey(1)
    if key ==ord('q'):                 #end processing
        break
    """
    
    n = n+ 1

cv2.destroyAllWindows()
img[0][0][0] = 1         #If you do not use it even once, I think it will be useless and add it

print(end_time-start_time)

Image capture (using pyautogui library)

Let's try it with the famous library "pyautogui".

It may be adjusted to 15,30,60fps, which is a good number according to the performance of the PC. Compared to mss, the load on both GPU and CPU is a little higher. There was almost no effect on the capture range. Since the load factor of any PC has a margin from the upper limit, it is wondering why there is a difference in performance.

However, the 15fps of the old PC is too low to use.

capture_test_pyautogui.py

import cv2			#OpenCV library
import numpy as np		#Numpy library
import pyautogui
import time

"""
For operation check: Comment out after operation check
"""
"""
windowName = "capture"
cv2.namedWindow(windowName)
"""
monitor = {"top": 300, "left": 170, "width": 600, "height": 600}
n= 0
while True:
    if n == 0:
        start_time = time.time()
        
    if n>= 1000:  #Repeated 100 times
        end_time = time.time()
        break
    """
Image acquisition
    """        
    home = pyautogui.screenshot(region=(0,0,600,200))
    img = np.asarray(home)
    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
    
    """
Operation check part
    """
    """
    img = img[:,:,0:3]
    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
    img = np.asarray(img)
    cv2.imshow(windowName,img)
    key = cv2.waitKey(1)
    if key ==ord('q'):                 #end processing
        break
    """
    
    n = n+ 1

cv2.destroyAllWindows()
img[0][0][0] = 1         #If you do not use it even once, I think it will be useless and add it

print(end_time-start_time)

OpenCV bench List the functions you want to try.

• cv2.matchTemplate
• cv2.circle
• Camera capture (camera used is 30fps)
• cv2.imshow
• cv2.minMaxLoc

Basically, I want to do image recognition, so it looks like this.

cv2.imshow Since the "same" image is displayed repeatedly, "different images" may give slightly different results. I was greatly influenced by the size of the image. I feel that the CPU load is high

Image size 100 * 100

Image size 300 * 300

Image size 800 * 800

Image size 2000 * 2000

result

• Almost no GPU effect, CPU dependent
• Strongly affected by screen size

Bench code

opencv_imshow.py

import cv2			#OpenCV library
import numpy as np		#Numpy library
import time

windowName = "capture"
cv2.namedWindow(windowName)

img = np.zeros((2000,2000,3))

n= 0
while True:
    if n == 0:
        start_time = time.time()
        
    if n>= 1000:  #Repeated 100 times
        end_time = time.time()
        break
    
    cv2.imshow(windowName,img)
    """
    #Operation test
    key = cv2.waitKey(1)
    if key ==ord('q'):                 #end processing
        break
    """
    n = n+ 1

cv2.destroyAllWindows()
img[0][0][0] = 1         #If you do not use it even once, I think it will be useless and add it

print(end_time-start_time)

cv2.circle

It doesn't seem to be a load at all.

opencv_circle.py

import cv2			#OpenCV library
import numpy as np		#Numpy library
import time

windowName = "capture"
cv2.namedWindow(windowName)

img = np.zeros((500,500,3))

n= 0
while True:
    if n == 0:
        start_time = time.time()
        
    if n>= 1000:  #Repeated 100 times
        end_time = time.time()
        break
    
    cv2.circle(img, (int(n*0.5),50), 10, (0, 0, 255), 4)
    
    """
Operation check part
    """
    """
    cv2.imshow(windowName,img)
    key = cv2.waitKey(1)
    if key ==ord('q'):                 #end processing
        break
    """
    
    
    n = n+ 1

cv2.destroyAllWindows()
img[0][0][0] = 1         #If you do not use it even once, I think it will be useless and add it

print(end_time-start_time)

cv2.matchTemplate This process has the heaviest image. Also, it was strongly influenced by the image size.

import cv2			#OpenCV library
import numpy as np		#Numpy library
import time

windowName = "capture"
cv2.namedWindow(windowName)

x = 100
y = 100
depth = 3
img = np.zeros((1000,1000,depth),dtype = np.uint8)
object1 = np.random.randint(0,255,(x,y,depth),dtype = np.uint8)

n= 0
while True:
    if n == 0:
        start_time = time.time()
        
    if n>= 100:  #Repeated 100 times
        end_time = time.time()
        break
    
    img_ccoeff = cv2.matchTemplate(img, object1, cv2.TM_CCOEFF_NORMED)

    n = n+ 1

cv2.destroyAllWindows()

print(end_time-start_time)

Camera capture (camera used is 30fps)

cv2.minMaxLoc

You can see that it hasn't taken any time.

minmaxLoc_bench.py

import cv2			#OpenCV library
import numpy as np		#Numpy library
import time

windowName = "capture"
cv2.namedWindow(windowName)

x = 100
y = 100
depth = 3
img = np.zeros((1000,1000,depth),dtype = np.uint8)
object1 = np.random.randint(0,255,(x,y,depth),dtype = np.uint8)
img_ccoeff = cv2.matchTemplate(img, object1, cv2.TM_CCOEFF_NORMED)

n= 0
while True:
    if n == 0:
        start_time = time.time()
        
    if n>= 1000:  #Repeated 100 times
        end_time = time.time()
        break
    
    cMin, cMax1, pMin, pMax1 = cv2.minMaxLoc(img_ccoeff)
    n = n+ 1

cv2.destroyAllWindows()

print(end_time-start_time)

I'm sorry. Since dbd was so much fun that it wasn't so much, I'll publish it for now and update it when I can afford it.