[PYTHON] Capture d'image / comparaison de la vitesse OpenCV avec et sans GPU

Aperçu

Récemment, j'ai fait un nouveau PC. Avant, quand je jouais avec OpenCV, le fps du traitement d'image n'était que d'environ 10 fps, et je pensais que c'était subtil, alors j'essaierai de savoir à quoi cela ressemble en changeant de PC. Ensuite, je comparerai le GPU avec le GTX1660super et les graphiques intégrés Intel.

Je pense que quelqu'un le fait déjà, mais je ne l'ai pas trouvé, alors je l'écris. Veuillez me faire savoir s'il existe d'autres articles faisant la même chose. Je veux lire.

environnement

• Python3 (Présentation d'anaconda3-Running avec Spyder)
• Windows 10 Home 64bit

Spécifications PC pour comparaison

Ancien PC

• core i5-6200U @2.3GHz 2core-4threads
• Intel HD Graphics 520
• 12 Go de mémoire
• SSD

Nouveau GPU intégré au PC

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

Nouveau PC-GPU

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

Résultat Cine-bench R20

Cela ne dépend pas du tout du GPU.

FFXV_bench 1920 * 1080, qualité standard

La mémoire est à peine suffisante et inutile sans GPU.

Banc de capture d'image

Capture d'image (à l'aide de la bibliothèque mss)

Vous pouvez capturer des écrans dans une bibliothèque appelée mss.

pip install mss

Est requis. Obtenez le temps écoulé $ [s] $ dans une bibliothèque appelée time. Comparez le temps nécessaire pour capturer l'écran 1000 fois. Je ne sais pas où se trouve le goulot d'étranglement. Si vous bouclez $ while $ sans acquérir l'image, elle n'a pas pu être mesurée au deuxième niveau, donc la partie capture d'image

sct.grab(monitor)

Je pense qu'il ne fait aucun doute que cela prend du temps.

Ceci est attendu car le taux de rafraîchissement de l'écran connecté au PC est réglé sur 59,94 Hz.

capture_test.py

import cv2			#Bibliothèque OpenCV
import numpy as np		#Bibliothèque Numpy
from mss import mss
import time

sct = mss()

"""
Pour le contrôle de fonctionnement: commenter après le contrôle de fonctionnement
"""
#windowName = "capture"
#cv2.namedWindow(windowName)

n= 0
while True:
    if n == 0:
        start_time = time.time()
        
    if n>= 1000:  #Répété 1000 fois
        end_time = time.time()
        break
    """
Acquisition d'image
    """        
    monitor = {"top": 300, "left": 170, "width": 600, "height": 200}
    img = np.array(sct.grab(monitor))
    
    """
Pièce de contrôle de fonctionnement
    """
    """
    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'):                 #terminer le traitement
        break
    """
    
    n = n+ 1

cv2.destroyAllWindows()
img[0][0][0] = 1         #Si vous ne l'utilisez pas même une fois, je pense que ce sera inutile et l'ajouter

print(end_time-start_time)

Capture d'image (à l'aide de la bibliothèque pyautogui)

Essayons-le avec la célèbre bibliothèque "pyautogui".

Il peut être ajusté à 15,30,60fps, ce qui est un bon nombre en fonction des performances du PC. Par rapport à mss, la charge sur le GPU et le CPU est un peu plus élevée. Il n'y avait presque aucun effet sur la plage de capture. Étant donné que le facteur de charge de tout PC a une marge par rapport à la limite supérieure, on se demande pourquoi il y a une différence de performances.

Cependant, les 15 ips de l'ancien PC sont trop faibles pour être utilisés.

capture_test_pyautogui.py

import cv2			#Bibliothèque OpenCV
import numpy as np		#Bibliothèque Numpy
import pyautogui
import time

"""
Pour le contrôle de fonctionnement: commenter après le contrôle de fonctionnement
"""
"""
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:  #Répété 100 fois
        end_time = time.time()
        break
    """
Acquisition d'image
    """        
    home = pyautogui.screenshot(region=(0,0,600,200))
    img = np.asarray(home)
    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
    
    """
Pièce de contrôle de fonctionnement
    """
    """
    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'):                 #terminer le traitement
        break
    """
    
    n = n+ 1

cv2.destroyAllWindows()
img[0][0][0] = 1         #Si vous ne l'utilisez pas même une fois, je pense que ce sera inutile et l'ajouter

print(end_time-start_time)

OpenCV bench Dressez la liste des fonctions que vous souhaitez essayer.

• cv2.matchTemplate
• cv2.circle
• Capture de l'appareil photo (appareil photo 30fps utilisé)
• cv2.imshow
• cv2.minMaxLoc

En gros, je veux faire de la reconnaissance d'image, donc ça ressemble à ça.

cv2.imshow Étant donné que la «même» image est affichée à plusieurs reprises, «des images différentes» peuvent donner des résultats légèrement différents. J'ai été grandement influencé par la taille de l'image. Je sens que la charge du processeur est élevée

Taille de l'image 100 * 100

Taille de l'image 300 * 300

Taille d'image 800 * 800

Taille de l'image 2000 * 2000

résultat

• Presque aucun effet du GPU, dépendant du CPU
• Fortement affecté par la taille de l'écran

Code du banc

opencv_imshow.py

import cv2			#Bibliothèque OpenCV
import numpy as np		#Bibliothèque Numpy
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:  #Répété 100 fois
        end_time = time.time()
        break
    
    cv2.imshow(windowName,img)
    """
    #Test de fonctionnement
    key = cv2.waitKey(1)
    if key ==ord('q'):                 #terminer le traitement
        break
    """
    n = n+ 1

cv2.destroyAllWindows()
img[0][0][0] = 1         #Si vous ne l'utilisez pas même une fois, je pense que ce sera inutile et l'ajouter

print(end_time-start_time)

cv2.circle

Cela ne semble pas du tout être une charge.

opencv_circle.py

import cv2			#Bibliothèque OpenCV
import numpy as np		#Bibliothèque Numpy
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:  #Répété 100 fois
        end_time = time.time()
        break
    
    cv2.circle(img, (int(n*0.5),50), 10, (0, 0, 255), 4)
    
    """
Pièce de contrôle de fonctionnement
    """
    """
    cv2.imshow(windowName,img)
    key = cv2.waitKey(1)
    if key ==ord('q'):                 #terminer le traitement
        break
    """
    
    
    n = n+ 1

cv2.destroyAllWindows()
img[0][0][0] = 1         #Si vous ne l'utilisez pas même une fois, je pense que ce sera inutile et l'ajouter

print(end_time-start_time)

cv2.matchTemplate Ce processus a l'image la plus lourde. En outre, il a été fortement influencé par la taille de l'image.

import cv2			#Bibliothèque OpenCV
import numpy as np		#Bibliothèque Numpy
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:  #Répété 100 fois
        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)

Capture de l'appareil photo (appareil photo 30fps utilisé)

cv2.minMaxLoc

Vous pouvez voir que cela n'a pas pris de temps.

minmaxLoc_bench.py

import cv2			#Bibliothèque OpenCV
import numpy as np		#Bibliothèque Numpy
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:  #Répété 100 fois
        end_time = time.time()
        break
    
    cMin, cMax1, pMin, pMax1 = cv2.minMaxLoc(img_ccoeff)
    n = n+ 1

cv2.destroyAllWindows()

print(end_time-start_time)

Je suis désolé. Étant donné que dbd était tellement amusant que ce n'était pas tellement amusant, je le publierai pour l'instant et le mettrai à jour quand j'en aurai les moyens.