Motivation

Résumé

La conversion d'affine a été effectuée avec OpenCV sur Python --Conclusion --CUDA hourra.
Le multithreading OpenCV est incroyable.

environnement

2*Xeon E5-2667 v3 @3.20 GHz
DDR4-2133 4*8 GB RAM
ubuntu LTS 20.04 @ Samsung Evo Plus 970 (500GB) --GTX 1080 (je veux RTX 30XX) --OpenCV 4.5.0 pre (4.5.0 pre Il n'y a pas de signification particulière. Si vous en avez envie, je voudrais le corriger autour de 4.4.0. Construction de l'environnement )
cuda 10.2, cnDNN 7.6.5

code

Prétraitement

Tout d'abord, lisez diverses choses, puis obtenez 200 * 200 maharo.jpg. Il s'agit du [Mahalo-kun] de Kawauso dans l'aquarium Sunshine (https://wikiwiki.jp/kawausotter/%E3%83%9E%E3%83%8F%E3%83%AD%EF%BC%88%E3% 82% B5% E3% 83% B3% E3% 82% B7% E3% 83% A3% E3% 82% A4% E3% 83% B3% E6% B0% B4% E6% 97% 8F% E9% A4% C'est une image de A8% EF% BC% 89). Voir Articles précédents pour plus de détails sur ce domaine.

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
print('Enabled CUDA devices:',cv.cuda.getCudaEnabledDeviceCount()) # 1

src = cv.cvtColor(cv.imread("maharo.jpg "),cv.COLOR_BGR2RGB)
h, w, c = src.shape #200, 200, 3
plt.subplot(111),plt.imshow(src)
plt.title('otter image'), plt.xticks([]), plt.yticks([])
plt.show()

g_src = cv.cuda_GpuMat()
g_dst = cv.cuda_GpuMat()
g_src.upload(src)

Tout d'abord, définissez la matrice de conversion affine. En combinant la rotation autour du centre et le mouvement parallèle, l'axe central est tourné par la rotation de l'échelle.

def get_rot_affine(src, rot, scale):
    h, w = src.shape[::-1]
    rot_affine = cv.getRotationMatrix2D((h/2, w/2), rot, scale)
    rot_affine[:2,2] -= [h/2, w/2]
    rot_affine[:2,2] += [h/2*scale, w/2*scale]
    return rot_affine

1x rotation de 20 degrés

Pour la même rotation de 20 degrés de grossissement, définissez la matrice d'affiliation comme suit. À propos, CUDA ne prend pas en charge l'interpolation Lanczos.

rot_affine = get_rot_affine(src, 20, 1)

CPU Tout d'abord, essayez-le sur le processeur.

%%timeit
img_dst = cv.warpAffine(src, rot_affine, (w*1, h*1), flags=cv.INTER_CUBIC)
# 1.08 ms ± 7.24 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

CUDA Je voudrais découvrir le goût des matériaux GPU en les traitant uniquement, ce qui n'inclut pas la lecture / l'écriture d'informations dans la boucle. Comme d'habitude, cv2.cuda.wrapAffine est utilisé, mais les arguments ne sont que l'image source src et l'image de sortie dst sur le GPU, et la matrice d'affiliation et la taille de dst sont les mêmes que cv.wrapAffine normal Semble utiliser. (Je me fâche quand je le mets sur le GPU).

%%timeit
g_dst = cv.cuda.warpAffine(g_src, rot_affine, (w*1, h*1), flags=cv.INTER_CUBIC)
# 383 µs ± 28.6 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

Eh bien, c'est comme ça ... Après tout, si l'image est petite, elle ne semble être qu'environ 2 à 3 fois plus efficace.

%%timeit
g_src.upload(src)
g_dst = cv.cuda.warpAffine(g_src, rot_affine, (w*1, h*1), flags=cv.INTER_CUBIC)
gpu_dst = g_dst.download()
# 450 µs ± 5.11 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Même si vous envisagez de lire / écrire, la vitesse ne change pas beaucoup. (Parce que l'image est claire)

Rotation 10 fois 20 degrés

Faites Mahalo 10 fois (2K) et faites-le pivoter de 20 degrés. La matrice affine est appelée comme suit.

rot_affine = get_rot_affine(src, 20, 10)

CPU Tout d'abord, essayez-le sur le processeur.

%%timeit
img_dst = cv.warpAffine(src, rot_affine, (w*10, h*10), flags=cv.INTER_CUBIC)
# 7.29 ms ± 36.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

C'est assez rapide pour un grossissement 10x. Cela dépend de l'environnement, la parallélisation ne fonctionnait pas bien lors du traitement d'images 200 px et le processeur fonctionnait avec 1 thread, mais lors du traitement d'images 2K, la parallélisation de 32 threads fonctionnait correctement. Cela dépend de la vitesse. (Si vous le faites avec un Core i5 / 7 normal, etc., ce sera plus lent. À propos, 2 * Xeon E5-2667 v3 @ 3,20 GHz dans l'environnement de vérification équivaut à environ 1 * Ryzen 9 3900XT selon Cinebench. C'est l'époque ...)

CUDA

%%timeit
g_dst = cv.cuda.warpAffine(g_src, rot_affine, (w*10, h*10), flags=cv.INTER_CUBIC)
# 1.42 ms ± 16.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Il est environ 5 fois plus rapide que le processeur. Eh bien, c'est assez facile à comprendre et rapide à moins que l'autre partie ne soit Xeon, mais il semble que GTX 1080 soit un peu mauvais.

%%timeit
g_src.upload(src)
g_dst = cv.cuda.warpAffine(g_src, rot_affine, (w*10, h*10), flags=cv.INTER_CUBIC)
gpu_dst = g_dst.download()
# 2.64 ms ± 163 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Lors de l'importation / exportation, cela prend un peu de temps car l'image est grande.

Le code utilisé cette fois (Jupyter Notebook) est publié sur Github.

référence

Comprendre complètement la conversion Affin

[PYTHON] Transformation affine par OpenCV (CUDA)