Extraction d'objets dans l'image par correspondance de modèles en utilisant OpenCV avec Python

introduction

Il y a eu une consultation, "N'est-il pas possible de trouver automatiquement le même objet dans l'image et de le découper en fonction de l'angle et de la position?"

La condition est que ce que vous voulez découvrir soit un objet et qu'un seul objet soit montré dans l'image.

J'ai eu un peu de mal à m'en rendre compte, je vais donc l'enregistrer. De plus, il semble qu'un réglage soit nécessaire en fonction de l'image (^ _ ^;)

Environnement d'exploitation

Procédure de construction de l'environnement

Veuillez vous référer à l'URL suivante pour le miso avant habituel.

• Procédure pour créer rapidement un environnement d'apprentissage en profondeur sur Mac avec TensorFlow et OpenCV

• Procédure pour créer rapidement un environnement d'apprentissage automatique avec Ubuntu 16.04

Photo utilisée

Première feuille (IMG_4754.JPG)

Deuxième pièce (IMG_4777.JPG)

Ici, la première pièce est traitée et éditée manuellement comme suit. (IMG_4754s.JPG)

Utilisez ceci comme image de modèle.

Lecture de la bibliothèque

python

import cv2
import math

De plus, déclarez la fonction suivante pour l'affichage de l'image.

python

from IPython.display import display, Image

def display_cv_image(image, format='.png'):
    decoded_bytes = cv2.imencode(format, image)[1].tobytes()
    display(Image(data=decoded_bytes))

Lecture d'image et extraction de caractéristiques

J'ai évoqué l'article suivant.

Correspondance de la quantité de fonctionnalités avec OpenCV 3 et Python 3 (A-KAZE, KNN)

python

#Lecture d'image
img1 = cv2.imread("IMG_4777.JPG")
img2 = cv2.imread("IMG_4754s.JPG")

# A-Génération de détecteur KAZE
detector = cv2.AKAZE_create()

#Détection d'entités et calcul de vecteurs d'entités
kp1, des1 = detector.detectAndCompute(img1, None)
kp2, des2 = detector.detectAndCompute(img2, None)

# Brute-Générer Force Matcher
bf = cv2.BFMatcher()

#Vecteurs de quantité de caractéristiques brutes-Correspondance avec Force et KNN
matches = bf.knnMatch(des1, des2, k=2)

#Affiner les données
ratio = 0.2
good = []
for m, n in matches:
    if m.distance < ratio * n.distance:
        good.append([m])

#Trier les fonctionnalités en fonction du statut correspondant
good = sorted(matches, key = lambda x : x[1].distance)

#Dessiner les points caractéristiques correspondants
img3 = cv2.drawMatchesKnn(img1, kp1, img2, kp2, good[:2], None, flags=2)

display_cv_image(img3, '.png')

L'image suivante s'affiche et vous pouvez voir que les points caractéristiques correspondent correctement.

Découpez en ajustant l'angle, la position et la taille

python

#Obtenir des données sur les fonctionnalités

q_kp = []
t_kp = []

for p in good[:2]:
    for px in p:
        q_kp.append(kp1[px.queryIdx])
        t_kp.append(kp2[px.trainIdx])

#Calculer l'angle et la distance entre les points caractéristiques de l'image à traiter
q_x1, q_y1 = q_kp[0]
q_x2, q_y2 = q_kp[-1]

q_deg = math.atan2(q_y2 - q_y1, q_x2 - q_x1) * 180 / math.pi
q_len = math.sqrt((q_x2 - q_x1) ** 2 + (q_y2 - q_y1) ** 2)

#Calculer l'angle et la distance entre les points caractéristiques à partir de l'image modèle
t_x1, t_y1 = t_kp[0]
t_x2, t_y2 = t_kp[-1]

t_deg = math.atan2(t_y2 - t_y1, t_x2 - t_x1) * 180 / math.pi
t_len = math.sqrt((t_x2 - t_x1) ** 2 + (t_y2 - t_y1) ** 2)

#Calcul de la position de coupure
x1 = q_x1 - t_x1 * (q_len / t_len)
x2 = x1 + img2.shape[1] * (q_len / t_len)

y1 = q_y1 - t_y1 * (q_len / t_len)
y2 = y1 + img2.shape[0] * (q_len / t_len)

#Taille de l'image
x, y, c = img1.shape
size = (x, y)

#Position centrale de rotation
center = (q_x1, q_y1)

#angle de rotation
angle = q_deg - t_deg

#Rapport de taille
scale = 1.0

#Calcul de la matrice de conversion de rotation
rotation_matrix = cv2.getRotationMatrix2D(center, angle, scale)

#Conversion d'affine
img_rot = cv2.warpAffine(img1, rotation_matrix, size, flags=cv2.INTER_CUBIC)

#Découpez l'image
img_rot = img_rot[y1:y2, x1:x2]

#Réglage de l'échelle
x, y, c = img2.shape
img_rot = cv2.resize(img_rot, (y, x))

#Affichage des résultats
display_cv_image(img_rot, '.png')

Lors de l'exécution, l'image suivante était affichée.

l'a fait!

Tâches futures

Il peut être utilisé pour des choses prises à une position fixe, comme une caméra à point fixe, mais si elle est inclinée, un autre processus est nécessaire.

Puisque nous faisons le même calcul à plusieurs reprises, il peut être préférable d'en faire une fonction et de le rendre plus facile à réutiliser ... Plutôt que cela.

... je vais retrouver le temps et y réfléchir (^ - ^)

20/08/2017 post-scriptum J'ai fait un petit test différent. Veuillez également voir. Essayez la conversion projective d'images en utilisant OpenCV avec Python